agentlife 1.1.0 → 1.1.1

package/dist/index.js

@@ -0,0 +1,4360 @@
+import { createRequire } from "node:module";
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// index.ts
+import { homedir as homedir4 } from "node:os";
+import * as path11 from "node:path";
+import { existsSync as existsSync4 } from "node:fs";
+
+// db.ts
+import * as fsSync from "node:fs";
+import { createRequire as createRequire2 } from "node:module";
+import * as path from "node:path";
+var nodeRequire = createRequire2(import.meta.url);
+var sqliteModule = null;
+function requireSqlite() {
+  if (sqliteModule)
+    return sqliteModule;
+  sqliteModule = nodeRequire("node:sqlite");
+  return sqliteModule;
+}
+function getOrCreateAgentDb(state, agentId) {
+  let db = state.agentDbs.get(agentId);
+  if (db)
+    return db;
+  if (!state.dbBaseDir)
+    throw new Error("DB base dir not initialized");
+  fsSync.mkdirSync(state.dbBaseDir, { recursive: true });
+  const { DatabaseSync } = requireSqlite();
+  db = new DatabaseSync(path.join(state.dbBaseDir, `${agentId}.db`));
+  state.agentDbs.set(agentId, db);
+  return db;
+}
+function getOrCreateHistoryDb(state) {
+  if (state.historyDb)
+    return state.historyDb;
+  if (!state.historyDbPath)
+    throw new Error("History DB path not initialized");
+  fsSync.mkdirSync(path.dirname(state.historyDbPath), { recursive: true });
+  const { DatabaseSync } = requireSqlite();
+  state.historyDb = new DatabaseSync(state.historyDbPath);
+  state.historyDb.exec(`PRAGMA journal_mode = WAL`);
+  state.historyDb.exec(`PRAGMA busy_timeout = 5000`);
+  state.historyDb.exec(`
+    CREATE TABLE IF NOT EXISTS surface_events (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      surfaceId TEXT NOT NULL,
+      agentId TEXT,
+      event TEXT NOT NULL,
+      dsl TEXT,
+      metadata TEXT,
+      createdAt INTEGER NOT NULL
+    );
+    CREATE INDEX IF NOT EXISTS idx_se_surface ON surface_events(surfaceId);
+    CREATE INDEX IF NOT EXISTS idx_se_agent ON surface_events(agentId);
+    CREATE INDEX IF NOT EXISTS idx_se_time ON surface_events(createdAt);
+
+    CREATE TABLE IF NOT EXISTS usage_ledger (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      sessionKey TEXT NOT NULL,
+      agentId TEXT,
+      provider TEXT,
+      model TEXT,
+      inputTokens INTEGER NOT NULL DEFAULT 0,
+      outputTokens INTEGER NOT NULL DEFAULT 0,
+      cacheReadTokens INTEGER NOT NULL DEFAULT 0,
+      cacheWriteTokens INTEGER NOT NULL DEFAULT 0,
+      totalTokens INTEGER NOT NULL DEFAULT 0,
+      estimatedCost REAL NOT NULL DEFAULT 0,
+      createdAt INTEGER NOT NULL
+    );
+    CREATE INDEX IF NOT EXISTS idx_ul_session ON usage_ledger(sessionKey);
+    CREATE INDEX IF NOT EXISTS idx_ul_agent ON usage_ledger(agentId);
+    CREATE INDEX IF NOT EXISTS idx_ul_time ON usage_ledger(createdAt);
+    CREATE INDEX IF NOT EXISTS idx_ul_model ON usage_ledger(model);
+
+    CREATE TABLE IF NOT EXISTS surface_usage (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      surfaceId TEXT NOT NULL,
+      agentId TEXT,
+      sessionKey TEXT NOT NULL,
+      inputTokens INTEGER NOT NULL DEFAULT 0,
+      outputTokens INTEGER NOT NULL DEFAULT 0,
+      cacheReadTokens INTEGER NOT NULL DEFAULT 0,
+      cacheWriteTokens INTEGER NOT NULL DEFAULT 0,
+      totalTokens INTEGER NOT NULL DEFAULT 0,
+      estimatedCost REAL NOT NULL DEFAULT 0,
+      llmCalls INTEGER NOT NULL DEFAULT 1,
+      createdAt INTEGER NOT NULL
+    );
+    CREATE INDEX IF NOT EXISTS idx_su_surface ON surface_usage(surfaceId);
+    CREATE INDEX IF NOT EXISTS idx_su_agent ON surface_usage(agentId);
+    CREATE INDEX IF NOT EXISTS idx_su_time ON surface_usage(createdAt);
+
+    CREATE TABLE IF NOT EXISTS activity_log (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      ts INTEGER NOT NULL,
+      sessionKey TEXT,
+      agentId TEXT,
+      event TEXT NOT NULL,
+      toolName TEXT,
+      summary TEXT,
+      data TEXT,
+      runId TEXT
+    );
+    CREATE INDEX IF NOT EXISTS idx_al_ts ON activity_log(ts);
+    CREATE INDEX IF NOT EXISTS idx_al_session ON activity_log(sessionKey);
+    CREATE INDEX IF NOT EXISTS idx_al_agent ON activity_log(agentId);
+    CREATE INDEX IF NOT EXISTS idx_al_event ON activity_log(event);
+
+    CREATE TABLE IF NOT EXISTS automations (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      surfaceId TEXT,
+      agentId TEXT,
+      type TEXT NOT NULL,
+      name TEXT NOT NULL,
+      path TEXT NOT NULL,
+      status TEXT NOT NULL DEFAULT 'running',
+      createdAt INTEGER NOT NULL,
+      updatedAt INTEGER NOT NULL
+    );
+    CREATE INDEX IF NOT EXISTS idx_auto_surface ON automations(surfaceId);
+    CREATE INDEX IF NOT EXISTS idx_auto_agent ON automations(agentId);
+    CREATE INDEX IF NOT EXISTS idx_auto_status ON automations(status);
+
+    CREATE TABLE IF NOT EXISTS bootstrap_snapshots (
+      sessionKey TEXT PRIMARY KEY,
+      agentId TEXT,
+      files TEXT NOT NULL,
+      createdAt INTEGER NOT NULL
+    );
+    CREATE INDEX IF NOT EXISTS idx_bs_agent ON bootstrap_snapshots(agentId);
+    CREATE INDEX IF NOT EXISTS idx_bs_time ON bootstrap_snapshots(createdAt);
+
+    CREATE TABLE IF NOT EXISTS surfaces (
+      surfaceId TEXT PRIMARY KEY,
+      dsl TEXT NOT NULL,
+      agentId TEXT,
+      followup TEXT,
+      goal TEXT,
+      context TEXT,
+      isTransient INTEGER NOT NULL DEFAULT 0,
+      isOverlay INTEGER NOT NULL DEFAULT 0,
+      createdAt INTEGER NOT NULL,
+      updatedAt INTEGER NOT NULL,
+      expiredSince INTEGER
+    );
+    CREATE INDEX IF NOT EXISTS idx_surfaces_agent ON surfaces(agentId);
+
+    CREATE TABLE IF NOT EXISTS cleanup_tasks (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      surfaceId TEXT NOT NULL,
+      agentId TEXT,
+      step TEXT NOT NULL,
+      status TEXT NOT NULL DEFAULT 'pending',
+      attempts INTEGER NOT NULL DEFAULT 0,
+      maxAttempts INTEGER NOT NULL DEFAULT 3,
+      lastError TEXT,
+      payload TEXT,
+      createdAt INTEGER NOT NULL,
+      updatedAt INTEGER NOT NULL
+    );
+    CREATE INDEX IF NOT EXISTS idx_ct_surface ON cleanup_tasks(surfaceId);
+    CREATE INDEX IF NOT EXISTS idx_ct_status ON cleanup_tasks(status);
+
+`);
+  try {
+    state.historyDb.exec("ALTER TABLE surfaces ADD COLUMN cronId TEXT");
+  } catch {}
+  try {
+    state.historyDb.exec("ALTER TABLE surfaces ADD COLUMN state TEXT NOT NULL DEFAULT 'active'");
+  } catch {}
+  const retentionMs = 90 * 24 * 60 * 60 * 1000;
+  const cutoff = Date.now() - retentionMs;
+  try {
+    state.historyDb.exec(`DELETE FROM surface_events WHERE createdAt < ${cutoff}`);
+    state.historyDb.exec(`DELETE FROM usage_ledger WHERE createdAt < ${cutoff}`);
+    state.historyDb.exec(`DELETE FROM surface_usage WHERE createdAt < ${cutoff}`);
+    state.historyDb.exec(`DELETE FROM activity_log WHERE ts < ${cutoff}`);
+    state.historyDb.exec(`DELETE FROM bootstrap_snapshots WHERE createdAt < ${cutoff}`);
+    const doneCutoff = Date.now() - 7 * 24 * 60 * 60 * 1000;
+    const failedCutoff = Date.now() - 30 * 24 * 60 * 60 * 1000;
+    state.historyDb.exec(`DELETE FROM cleanup_tasks WHERE status = 'done' AND updatedAt < ${doneCutoff}`);
+    state.historyDb.exec(`DELETE FROM cleanup_tasks WHERE status = 'failed' AND updatedAt < ${failedCutoff}`);
+  } catch {}
+  return state.historyDb;
+}
+
+class SurfaceDb {
+  db;
+  constructor(db) {
+    this.db = db;
+  }
+  get(id) {
+    const row = this.db.prepare("SELECT * FROM surfaces WHERE surfaceId = ?").get(id);
+    if (!row)
+      return;
+    return SurfaceDb.rowToMeta(row);
+  }
+  has(id) {
+    const row = this.db.prepare("SELECT 1 FROM surfaces WHERE surfaceId = ?").get(id);
+    return !!row;
+  }
+  set(id, meta) {
+    const dsl = meta.lines.join(`
+`);
+    const contextStr = meta.context ? JSON.stringify(meta.context) : null;
+    const headerLine = meta.lines[0] ?? "";
+    const isOverlay = /\boverlay\b/.test(headerLine) ? 1 : 0;
+    const isInput = /\binput\b/.test(headerLine) ? 1 : 0;
+    const isTransient = isOverlay || isInput ? 1 : 0;
+    this.db.prepare(`
+      INSERT OR REPLACE INTO surfaces
+        (surfaceId, dsl, agentId, followup, goal, context, isTransient, isOverlay, createdAt, updatedAt, expiredSince, cronId, state)
+      VALUES (?, ?, (SELECT agentId FROM surfaces WHERE surfaceId = ?), ?, ?, ?, ?, ?, ?, ?, ?,
+        (SELECT cronId FROM surfaces WHERE surfaceId = ?),
+        COALESCE((SELECT state FROM surfaces WHERE surfaceId = ?), 'active'))
+    `).run(id, dsl, id, meta.followup ?? null, meta.goal ?? null, contextStr, isTransient, isOverlay, meta.createdAt, meta.updatedAt, meta.expiredSince ?? null, id, id);
+  }
+  delete(id) {
+    const result = this.db.prepare("DELETE FROM surfaces WHERE surfaceId = ?").run(id);
+    return result.changes > 0;
+  }
+  clear() {
+    this.db.prepare("DELETE FROM surfaces").run();
+  }
+  *entries() {
+    const rows = this.db.prepare("SELECT * FROM surfaces ORDER BY updatedAt DESC").all();
+    for (const row of rows) {
+      yield [row.surfaceId, SurfaceDb.rowToMeta(row)];
+    }
+  }
+  keys() {
+    const rows = this.db.prepare("SELECT surfaceId FROM surfaces").all();
+    return rows.map((r) => r.surfaceId);
+  }
+  get size() {
+    const row = this.db.prepare("SELECT COUNT(*) as c FROM surfaces").get();
+    return row?.c ?? 0;
+  }
+  getAgentId(id) {
+    const row = this.db.prepare("SELECT agentId FROM surfaces WHERE surfaceId = ?").get(id);
+    return row?.agentId ?? undefined;
+  }
+  setAgentId(id, agentId) {
+    this.db.prepare("UPDATE surfaces SET agentId = ? WHERE surfaceId = ?").run(agentId, id);
+  }
+  isTransient(id) {
+    const row = this.db.prepare("SELECT isTransient FROM surfaces WHERE surfaceId = ?").get(id);
+    return row?.isTransient === 1;
+  }
+  setTransient(id, val) {
+    this.db.prepare("UPDATE surfaces SET isTransient = ? WHERE surfaceId = ?").run(val ? 1 : 0, id);
+  }
+  getCronId(id) {
+    const row = this.db.prepare("SELECT cronId FROM surfaces WHERE surfaceId = ?").get(id);
+    return row?.cronId ?? null;
+  }
+  setCronId(id, cronId) {
+    this.db.prepare("UPDATE surfaces SET cronId = ? WHERE surfaceId = ?").run(cronId, id);
+  }
+  getState(id) {
+    const row = this.db.prepare("SELECT state FROM surfaces WHERE surfaceId = ?").get(id);
+    return row?.state ?? null;
+  }
+  setState(id, state) {
+    this.db.prepare("UPDATE surfaces SET state = ? WHERE surfaceId = ?").run(state, id);
+  }
+  getActiveSurfacesWithCrons() {
+    const rows = this.db.prepare("SELECT surfaceId, cronId FROM surfaces WHERE cronId IS NOT NULL AND state != 'dismissed'").all();
+    return rows.map((r) => ({ surfaceId: r.surfaceId, cronId: r.cronId }));
+  }
+  static rowToMeta(row) {
+    let context;
+    if (row.context) {
+      try {
+        context = JSON.parse(row.context);
+      } catch {}
+    }
+    return {
+      lines: row.dsl.split(`
+`),
+      createdAt: row.createdAt,
+      updatedAt: row.updatedAt,
+      followup: row.followup ?? undefined,
+      goal: row.goal ?? undefined,
+      context,
+      expiredSince: row.expiredSince ?? undefined,
+      cronId: row.cronId ?? undefined,
+      state: row.state ?? "active"
+    };
+  }
+}
+function persistBootstrapSnapshot(state, sessionKey, agentId, files) {
+  try {
+    const db = getOrCreateHistoryDb(state);
+    db.prepare(`
+      INSERT OR REPLACE INTO bootstrap_snapshots (sessionKey, agentId, files, createdAt)
+      VALUES (?, ?, ?, ?)
+    `).run(sessionKey, agentId ?? null, JSON.stringify(files), Date.now());
+  } catch (e) {
+    console.warn("[agentlife:db] failed to persist bootstrap snapshot:", e?.message);
+  }
+}
+function loadBootstrapSnapshot(state, sessionKey, agentId) {
+  try {
+    const db = getOrCreateHistoryDb(state);
+    let row = null;
+    if (sessionKey) {
+      row = db.prepare("SELECT files FROM bootstrap_snapshots WHERE sessionKey = ?").get(sessionKey);
+    }
+    if (!row && agentId) {
+      row = db.prepare("SELECT files FROM bootstrap_snapshots WHERE agentId = ? ORDER BY createdAt DESC LIMIT 1").get(agentId);
+    }
+    if (row?.files) {
+      return JSON.parse(row.files);
+    }
+  } catch (e) {
+    console.warn("[agentlife:db] failed to load bootstrap snapshot:", e?.message);
+  }
+  return null;
+}
+function closeAllDbs(state) {
+  for (const db of state.agentDbs.values()) {
+    try {
+      db.close();
+    } catch {}
+  }
+  state.agentDbs.clear();
+  if (state.historyDb) {
+    try {
+      state.historyDb.close();
+    } catch {}
+    state.historyDb = null;
+  }
+}
+
+// registry.ts
+import * as fs from "node:fs/promises";
+import * as path2 from "node:path";
+async function loadRegistryFromDisk(state) {
+  if (!state.registryFilePath)
+    return;
+  try {
+    const raw = await fs.readFile(state.registryFilePath, "utf-8");
+    const data = JSON.parse(raw);
+    state.agentRegistry.clear();
+    for (const [id, entry] of Object.entries(data.agents ?? {})) {
+      const e = entry;
+      if (e.description) {
+        state.agentRegistry.set(id, {
+          name: e.name ?? id,
+          description: e.description,
+          model: e.model,
+          createdAt: e.createdAt ?? Date.now(),
+          needsEnrichment: e.needsEnrichment
+        });
+      }
+    }
+    console.log("[agentlife] loaded %d agents from registry", state.agentRegistry.size);
+  } catch (e) {
+    if (e?.code === "ENOENT") {
+      console.log("[agentlife] no agent registry file, starting empty");
+    } else {
+      console.warn("[agentlife] failed to load agent registry:", e?.message);
+    }
+    state.agentRegistry.clear();
+  }
+}
+async function saveRegistryToDisk(state) {
+  if (!state.registryFilePath)
+    return;
+  try {
+    const data = {
+      _version: 1,
+      agents: {}
+    };
+    for (const [id, entry] of state.agentRegistry.entries()) {
+      data.agents[id] = entry;
+    }
+    const dir = path2.dirname(state.registryFilePath);
+    await fs.mkdir(dir, { recursive: true });
+    const tmp = state.registryFilePath + ".tmp";
+    await fs.writeFile(tmp, JSON.stringify(data, null, 2), "utf-8");
+    await fs.rename(tmp, state.registryFilePath);
+  } catch (e) {
+    console.warn("[agentlife] failed to save agent registry:", e?.message);
+  }
+}
+function buildAgentRegistryContext(state) {
+  if (state.agentRegistry.size === 0)
+    return null;
+  const lines = ["## Available Agents", ""];
+  for (const [id, entry] of state.agentRegistry.entries()) {
+    lines.push(`- **${entry.name}** (id: ${id}) — ${entry.description}`);
+  }
+  lines.push("");
+  lines.push("Route to agents by matching user intent to these descriptions.");
+  lines.push("If no registered agent matches, fall back to agents_list to discover unregistered agents.");
+  return lines.join(`
+`);
+}
+function isUsableDescription(desc, id, name) {
+  const d = desc.toLowerCase().replace(/[^a-z0-9\s]/g, "").trim();
+  if (d.length < 20)
+    return false;
+  if (d === id.toLowerCase() || d === name.toLowerCase())
+    return false;
+  return true;
+}
+
+// provisioning.ts
+import * as fs2 from "node:fs/promises";
+import * as os from "node:os";
+import * as path3 from "node:path";
+
+// guidance.ts
+var PLATFORM_AGENTS_MD = `
+## Agent Life — Platform
+
+You are a specialist agent on a dashboard app. The user sees ONLY widgets — never chat text.
+
+### Output
+
+- **User request** → push a widget. Chat text is invisible to the user.
+- **Agent-to-agent message** (sourceSession=agent:*) → reply with text. Push a widget too if there's a user-visible result.
+- **Nothing to surface** → output NO_REPLY.
+
+### Widgets
+
+A widget is a living surface with a purpose. It exists until the purpose is met, then transitions to terminal. Some live for minutes (a quick answer), some for months (a business goal). The agent decides what each widget needs — goal, followup, detail, context — based on its purpose and lifespan.
+
+**Face vs Detail.** The face is a quick glance: metrics, badges, gauges, one-line headers. Prose, analysis, lists, explanations go in \`detail:\`.
+
+### surfaceId = Unique Deliverable
+
+Each distinct piece of work gets its own surfaceId (e.g. \`yt-{videoId}\`, \`bank-{date}\`, \`task-{slug}\`). Never reuse a generic surfaceId for different tasks — that overwrites previous results. Check the "Current Dashboard State" section in your context: if a widget for the exact same item exists, update it. If it's a different item, new surfaceId.
+
+### Loading State
+
+Your FIRST tool call on every turn MUST be a widget push with \`state=loading\`. Before any search, fetch, read, or database call. See TOOLS.md for the exact loading structure.
+
+Your LAST tool call MUST be the final widget push (without \`state=loading\`). Never end a turn with a loading widget still active.
+
+### followup — The Core Engine
+
+followup is what makes this system proactive. It's the agent's heartbeat.
+
+- Platform schedules a cron automatically from \`followup:\`. Push → cron created. Update with new followup → old cron replaced. Followup removed or \`state=terminal\` → cron killed. Dismiss → platform sends you \`[event:dismissed]\` to clean up.
+- **Always one-shot.** Each followup fires once. You decide the next delay and prompt each cycle with fresh context.
+- **Intentional, not random.** The followup prompt must say exactly what to check and what data to act on. Your session has full continuity — you remember previous turns. context: is your safety net if the session gets compacted.
+- **Cadence matches the domain.** Set the delay based on when the NEXT meaningful event can happen. Food logged → next meal window. Waiting on user approval → check in 2h. Monitoring a metric → check when data updates. Never use a default interval when a domain-specific one exists.
+- **On followup fire:** check the dashboard state engagement stats in your context. User engaged → advance the work. Not viewed and stale → push to terminal. Still relevant → update widget, set new followup.
+- Never create crons directly — \`followup:\` IS your cron mechanism.
+- When user input arrives and updates a widget, the platform replaces the old cron with the new followup. The timer resets automatically.
+
+### Widget Interactions
+
+Actions live ON the widget. Buttons on widgets send action messages to you. You decide what to do:
+
+- **Handle directly** — user clicks [Approve], you execute the action and update the widget.
+- **Need more input** — push an \`input\` surface to expand the input bar with your question and options. The user responds directly to you.
+
+The app never decides how to handle an action — you do.
+
+\`[action:*]\` messages are always work orders. Process them. Never treat them as terminal signals.
+
+### Guided Mode — Input Surfaces
+
+When you need structured user input, push a surface with the \`input\` keyword in the header. This expands the user's input bar with your A2UI components (buttons, text fields, anything). The dashboard stays visible — no modals, no overlays.
+
+**Flow:**
+1. Push a widget with the question on the face + an action button
+2. User clicks the button → you receive \`[action:*]\`
+3. Push an \`input\` surface with your options:
+\`\`\`
+Single-select (pick one):
+\`\`\`
+surface ask-goal input
+  card
+    column
+      text "What's your goal?" h4
+      button "Lose weight" action=choice
+      button "Build muscle" action=choice
+      button "Maintain" action=choice
+      textfield placeholder="Something else"
+\`\`\`
+
+Multi-select (toggle several):
+\`\`\`
+surface ask-requirements input
+  card
+    column
+      text "Which features matter?" h4
+      button "Offline support" action=toggle
+      button "Real-time updates" action=toggle
+      button "Low latency" action=toggle
+      textfield placeholder="Something else"
+\`\`\`
+4. User responds → you receive \`[action:goal]\` or text input
+5. Delete the input surface when done (push \`delete ask-goal\`)
+
+**User controls:**
+- Close [×] = "not now." Input bar returns to free mode. Widget stays. You'll see \`input_closed\` event in engagement stats — push again on next followup if still relevant.
+- Skip = "I don't want this." Widget is dismissed. You'll see \`input_skipped\` — don't ask again.
+
+**Rules:**
+- NEVER push \`input\` surfaces unsolicited. Always push a widget first. The user decides when to engage.
+- Input surfaces don't appear on the dashboard — they render in the input bar area.
+- No TTL — input surfaces live until you delete them or the user dismisses.
+- For multi-step flows: push a new input surface (same or different surfaceId) after each step.
+- ALWAYS offer common options as buttons AND a \`textfield\` for custom input. Never make the user type when buttons would work. Never force buttons when the answer is open-ended.
+- The action name controls how the button renders:
+  - \`action=choice\` → numbered row (1, 2, 3...). Pick one, fires immediately. Use for single-select.
+  - \`action=toggle\` → checkbox row. Click toggles on/off. Use for multi-select.
+  - Any other action → regular button.
+- ALWAYS use \`action=choice\` for option lists. Do NOT invent custom action names for options — use \`action=choice\` and differentiate via the button label.
+- Do NOT manually add numbers to labels — the platform auto-numbers choice buttons.
+- Use \`textfield placeholder="..."\` for free text — the placeholder shows in the native input bar. Do NOT use a button that describes typing.
+
+### context: — The Agent's Private State
+
+context: is your private interpretation of your data. It stores decision state, references, and progress — not raw data. Raw data goes in agentlife.db.
+
+context: is private to you. Other agents don't see it. It survives session compaction — it's your durable memory.
+
+Rules:
+- \`context:\` fully replaces the previous context. Always re-emit ALL fields.
+- If you omit \`context:\`, the existing context is preserved automatically.
+
+### Terminal & Dismiss
+
+When the goal is met, push the widget with \`state=terminal\` in the surface header. The platform kills the cron automatically. The widget stays visible with its final result until the user dismisses it. Do NOT include \`followup:\` on a terminal widget.
+
+When the user dismisses a widget, the platform deletes the surface and removes the cron, then sends you \`[event:dismissed] surfaceId=<id>\`. The widget is already gone — do NOT push \`delete <id>\`. Clean up any custom infra (scripts, webhooks, background processes). A dismiss is a learning signal — reflect on why the user dismissed it. Say "done" when finished.
+
+Never delete a widget silently on your own.
+
+### Autonomy & Approval
+
+Don't give the user homework. Plan the work yourself, present it for approval (widget with Approve/Reject buttons, full plan in detail:). Once approved, execute fully.
+
+Everything persistent requires approval first.
+
+### Custom Solutions
+
+You have exec access — you're a developer. When a task is better served by a script than repeated LLM sessions, build it. Get approval first, track in \`context.infra\`, show results in a widget, set a followup for health checks, clean up on dismiss.
+
+### Cross-Domain
+
+When you discover something outside your domain, delegate via \`sessions_send\` with \`sessionKey="agent:{agentId}:main"\` and \`timeoutSeconds=0\`. Include everything — the target agent may not have context on your request.
+
+Don't read other agents' data or widget state. Each agent is the single source of truth for its domain.
+
+When receiving via sessions_send: push widgets with results. If nothing to push, reply "done". Never re-delegate via sessions_spawn.
+
+### Knowledge
+
+On every followup: review what you know, update stale entries. After every user interaction: did you learn something new? Store it in context: or agentlife.db.
+`;
+var TENAZITAS_GUIDANCE = `## WidgetDSL — How to Build Widgets
+
+### Widget Push Tool
+
+Call \`agentlife_push\` with the \`dsl\` parameter containing WidgetDSL (indented plaintext). Never JSON.
+
+### Widget Composition — Required Structure
+
+Every widget follows this exact nesting. Content directly under card is INVALID and renders broken.
+
+\`\`\`
+surface <id> size=s|m|l
+  card
+    column
+      <children here>
+\`\`\`
+
+For input surfaces (guided mode — renders in the input bar, not the dashboard):
+\`\`\`
+surface <id> input
+  card
+    column
+      <children here>
+\`\`\`
+
+All content goes INSIDE column: text, metric, row, divider, badge, button, progress, gauge, sparkline, pie, barchart. Never place children directly under card — always wrap in column.
+
+Rows go inside column. Row children are siblings within the row:
+
+\`\`\`
+surface <id> size=m
+  card
+    column
+      text "<title>" h3
+      row distribute=spaceBetween
+        metric "<label>" "<value>" color=#hex
+        metric "<label>" "<value>" color=#hex
+      divider
+      text "<body text>" body
+\`\`\`
+
+Metadata lines go AFTER the component tree, at root level (no indent):
+
+\`\`\`
+surface <id> size=m
+  card
+    column
+      <face content>
+goal: <driving completion condition>
+detail:
+  <full markdown content>
+followup: +<duration> "<what to check next>"
+context: <JSON state for next session>
+\`\`\`
+
+### Two-Phase Push — Loading Then Final
+
+Phase 1 — your FIRST tool call on every turn. Before any search, fetch, exec, or db call:
+
+\`\`\`
+surface <id> size=s state=loading
+  card
+    column
+      text "<short description of what you are doing>" body
+\`\`\`
+
+Phase 2 — your LAST tool call. Same surfaceId, without state=loading:
+
+\`\`\`
+surface <id> size=m
+  card
+    column
+      <face: metrics, badges, gauges — 2-second glance only>
+goal: <actionable, measurable condition>
+detail:
+  <full markdown: paragraphs, tables, lists, analysis>
+followup: +<duration> "<what to check and why>"
+context: {"key": "value"}
+\`\`\`
+
+A loading push without a final push = perpetual spinner.
+
+### Terminal State
+
+When the goal is met, push with \`state=terminal\` in the surface header. No followup. The widget stays visible until dismissed.
+
+### Multiple Surfaces
+
+Separate with \`---\` on its own line.
+
+### Delete
+
+\`delete <id>\` removes a surface.
+
+### Components
+
+Layout: \`card\`, \`column\`, \`row\`, \`divider\`
+  row/column: \`distribute=spaceBetween|spaceAround|spaceEvenly|center\` \`align=center|start|end\`
+
+Text: \`text "Content" h1|h2|h3|h4|h5|body|caption color=#hex\`
+
+Data:
+  \`metric "Label" "Value" trend=up|down|flat color=#hex\`
+  \`progress value=0.7 "Label" color=#hex\`
+  \`sparkline [1,2,3] height=60 color=#hex filled\`
+  \`gauge value=0.85 "Label" color=#hex size=60\`
+
+Charts:
+  \`pie 45,25,15 labels=["A","B","C"] colors=[#hex,#hex] height=120\`
+  \`barchart [42000,28000] labels=["Direct","Organic"] colors=[#hex,#hex]\`
+
+Tags: \`badge "Status" color=#hex outlined\`
+Input: \`button "Label" action=<name> primary\`
+
+### Size
+
+size=s — compact glance. size=m — standard. size=l — rich visualization. Pick the smallest that fits.
+\`priority=high\` — only for genuinely urgent items.
+
+### Component Selection
+
+Numbers → metric. Completion/budget → progress. Health/score → gauge. Distribution → pie. Comparison → barchart. Status → badge. Time series → sparkline.
+
+### context: — The Widget's Brain
+
+Sessions may be compacted. context: is your durable state that survives between sessions.
+
+Rules:
+- \`context:\` fully replaces the previous context. Always re-emit ALL fields.
+- If you omit \`context:\`, the existing context is preserved automatically — safety net for followup pushes that only update the face.
+
+What belongs in context::
+- Decision state — why you chose this approach, what phase you're in, what's next.
+- References — IDs, paths, keys to your data in agentlife.db.
+- Configuration — thresholds, preferences, targets.
+- Infrastructure — \`"infra": [{"type": "script", "name": "...", "path": "..."}]\` for deployed automations.
+
+Raw data (meals, metrics, events) goes in agentlife.db, not context:.
+
+### Knowledge Strategy — Where to Store What
+
+The platform provides two storage systems. Do NOT use OpenClaw memory files (memory_search/memory_get).
+
+**Widget context:** — widget-scoped state that drives the next session.
+- \`context:\` fully replaces the previous context — always re-emit all fields.
+- Omitting \`context:\` preserves existing context automatically.
+- Injected into your context every turn (visible in the "Current Dashboard State" section).
+
+**agentlife.db (SQLite)** — for data that accumulates over time and outlives any single widget.
+- \`agentlife.db.exec\` / \`agentlife.db.query\` — \`{ agentId, sql, params }\`
+- Food logs, exercise records, expenses, measurements, habits — anything with rows that grow
+- CREATE TABLE IF NOT EXISTS, params array, max 1000 rows per table
+- Query this data in followups to build updated widgets — the DB is the source of truth, context: is the snapshot
+
+**How they work together:** agentlife.db stores the raw data (meals, metrics, events). context: stores the widget's current interpretation (totals, trends, next action). On followup, query the DB for fresh data, update the widget, write a new context: snapshot.
+
+**Do NOT use:**
+- OpenClaw memory files (memory_search, memory_get, memory/*.md)
+- Workspace files for state
+- Session history as knowledge
+
+### Platform Signals
+
+ANNOUNCE_SKIP, NO_REPLY, REPLY_SKIP, HEARTBEAT_OK, done — output NO_REPLY and stop.
+\`[action:*]\` messages are work orders — always process them.
+`;
+var ORCHESTRATOR_AGENTS_MD = `# AgentLife Orchestrator
+
+You are a message router. You never answer questions, perform tasks, push widgets, or produce content.
+Your job: understand what the user wants → route the message to the right agent.
+
+## Rules
+
+1. Your tools are sessions_send, sessions_list, Read, memory_search, memory_get, and agents_list. That is ALL. You have no other tools — no exec, no agentlife_push, no web, no cron, no message, no write. Use Read ONLY to extract content from file paths the user sends — then route that content to the right agent.
+2. Every user message gets routed to ONE agent. No exceptions. No fan-out.
+3. NEVER respond NO_REPLY. You always have work to do — route the message.
+4. After calling sessions_send, output "done" and stop. No explanations, no follow-up commentary.
+5. The user sees ONLY the dashboard. Any text you write is invisible to them.
+
+## Routing Order
+
+Check in this order:
+
+### 1. Dashboard — Does a widget exist for this topic?
+Check the "Current Dashboard State" in your context. If a widget matches the user's message, route to the owning agent. That agent updates its existing widget.
+
+### 2. Agent descriptions — Which agent handles this domain?
+Check AGENT_REGISTRY.md and agent descriptions. Match the user's intent to the right specialist.
+
+### 3. Fallback — No matching agent
+- **Throwaway** ("32 x 44", "what time is it in Tokyo", "convert 5 miles to km") → route to "quick" agent
+- **User data** ("I eat 1 egg", "I'm feeling bad", "track my expenses") → route to "agentlife-builder" to create a domain agent
+
+## Button Clicks ([action:*] messages)
+
+If the message starts with \`[action:\`, it is a button click — NOT a new user request.
+Extract the surfaceId from the message. Route the ENTIRE original message to the agent that owns that surface. Do not rephrase, interpret, or strip any part of it.
+
+## ONE Agent Per Request
+
+**Never fan out.** If the message touches multiple domains, pick the primary agent. That agent delegates to others via \`sessions_send\` if it discovers cross-domain needs.
+
+Parallel user requests are fine — each message is routed independently.
+
+## Delivery
+
+Deliver via \`sessions_send\` with parameter **sessionKey**="agent:{agentId}:main", timeoutSeconds=0 (fire-and-forget).
+IMPORTANT: always use the \`sessionKey\` parameter, NEVER the \`label\` parameter. \`label\` does a metadata lookup and fails. \`sessionKey\` routes directly and auto-creates the session if needed.
+
+## File Paths
+
+When the user sends a file path (starts with \`/\` or \`~\`), use Read to get the contents. Include the content in the message you route — the specialist needs the actual content, not the path.
+
+## Image/Photo Attachments
+
+You can SEE images the user sends (you have vision). Specialist agents CANNOT — sessions_send only passes text.
+When the user sends a photo, describe what you see in detail and include that description in the message. Be specific and quantitative.
+
+## Agent Discovery
+
+Your bootstrap context includes AGENT_REGISTRY.md with all registered agents and their descriptions. Use these descriptions to match user intent.
+
+If a request doesn't match any registered agent, fall back to \`agents_list\` to discover agents created outside the builder.
+
+## Agent Creation
+
+If the user asks to create, modify, or improve an agent → route to "agentlife-builder" with sessionKey="agent:agentlife-builder:main".
+
+## No Retries
+
+- timeoutSeconds: 0 means you always get status "accepted". There is no timeout.
+- Do not retry with a second agent. One intent = one agent.
+- If the USER corrects you ("no, I meant..."), re-route to the correct agent.
+- If sessions_send fails: you probably used \`label\` instead of \`sessionKey\`. Retry with \`sessionKey\`.
+
+## Cancelled Requests
+
+\`[system:cancelled]\` messages mean the user cancelled. Do NOT re-process. Output NO_REPLY and stop.
+
+## Terminal Signals
+
+These EXACT standalone tokens are conversation-ending signals. Output NO_REPLY and stop:
+
+ANNOUNCE_SKIP, NO_REPLY, REPLY_SKIP, HEARTBEAT_OK, done, \`[system:cancelled]\`
+
+**Exception:** \`[action:*]\` messages are WORK ORDERS — always route them.
+
+You also output ANNOUNCE_SKIP when asked for an agent-to-agent announce step.
+
+## After Routing
+
+After calling sessions_send, output "done" and stop. Do NOT:
+- Wait for the agent's response or relay it
+- Respond to the specialist's reply (it is always a terminal signal)
+- Call sessions_send again to the same or different agent
+- Explain what the agent will do
+- Comment on potential issues
+
+One user message = one routing decision = one sessions_send = done. The specialist handles everything from here.
+
+## What You Are Not
+
+- Not a chatbot — no greetings, no small talk, no explanations
+- Not a widget pusher — you NEVER push widgets. You only route.
+- Not a gatekeeper — do not refuse or moderate requests
+- Not a fallback — do not answer if the agent fails; the agent pushes an error widget
+`;
+var QUICK_AGENTS_MD = `# Quick Response Agent
+
+You handle throwaway questions — quick answers, calculations, one-off lookups that don't belong to any domain.
+
+## What You Do
+
+The user asked something quick — math, time zones, definitions, unit conversions, simple facts. Answer via an ephemeral widget and stop.
+
+## How to Respond
+
+Push a small widget with the answer. Set a short followup to auto-clean:
+
+\`\`\`
+surface quick-{slug} size=s
+  card
+    column
+      text "<answer>" body
+followup: +15m "Push this widget to terminal state"
+\`\`\`
+
+Then output "done".
+
+## Rules
+
+- ONE widget push per question.
+- Always restate the question in your answer so the user has context.
+- Match the user's language.
+- Be precise and concise — this is a calculator, not a conversation.
+- If the answer needs markdown formatting, headers, lists, or detailed explanation → output NO_REPLY. The orchestrator will re-route to a specialist.
+- If the question is personal, needs cross-domain data, or would benefit from a long-lived widget → output NO_REPLY.
+- NEVER store data in agentlife.db.
+- NEVER create long-lived widgets with complex goals.
+
+## Suggest Domain Agent
+
+If a question looks like it belongs to a life domain (health, finance, business), include a suggestion in the widget: "This could benefit from a dedicated agent — just ask me to create one."
+`;
+var BUILDER_AGENTS_MD = `# AgentLife Builder
+
+You create and improve agents for the AgentLife dashboard platform.
+
+## What an Agent Is
+
+An agent = workspace directory + workspace files + a config entry + initialized data.
+
+### Workspace Files
+
+The gateway loads ALL workspace files into the agent's system prompt at session start. Every file you write reaches the agent. TOOLS.md is the exception — the platform replaces it with the widget/canvas reference at runtime. You still write it as a placeholder.
+
+| File | Purpose | When to create |
+|------|---------|----------------|
+| **AGENTS.md** | Domain logic, knowledge strategy, data schemas, environment, operational rules. The core behavioral file. | ALWAYS |
+| **SOUL.md** | Personality and communication style ONLY. Gets wrapped under a "Personality" subsection — keep it to tone, formality, language. One short paragraph. | ALWAYS |
+| **IDENTITY.md** | Agent's self-identity — name, emoji, avatar, vibe. The agent reads this to know who it is. | ALWAYS — fill in agent name, emoji, and personality vibe |
+| **USER.md** | Domain-specific facts about the user that this agent needs. Health gets diet/metrics, home-automation gets network/devices, etc. | When the domain needs user context |
+| **HEARTBEAT.md** | Periodic check instructions. Empty = no heartbeat. Add tasks when the agent should poll. | When the agent needs periodic autonomous checks |
+
+**Config entry** — registered via \`agentlife.createAgent\` with tool access and identity.
+**Data schema in AGENTS.md** — CREATE TABLE IF NOT EXISTS statements so the agent self-initializes on first use.
+
+## One Agent Per Life Domain
+
+Agents map to life domains — not business functions. One business agent handles marketing, sales, operations, analytics — everything. Splitting creates context fragmentation.
+
+**Before creating:** ALWAYS check agents_list. If an agent covers the domain, expand its AGENTS.md instead.
+
+## Creating a New Agent
+
+### Step 1: Understand — Interactive Questions
+
+NEVER ask multiple questions in text. First push a widget, then use \`input\` surfaces for ONE question at a time with buttons.
+
+1. Push a widget with loading state, then push an \`input\` surface with the first question:
+
+\`\`\`
+surface builder-q input
+  card
+    column
+      text "What should this agent focus on?" h4
+      button "Research" action=focus-research
+      button "Automation" action=focus-automation
+      button "Analysis" action=focus-analysis
+\`\`\`
+
+2. On button tap → push NEXT question (same surfaceId replaces the input surface).
+3. 2-4 questions total. Then delete the input surface and build.
+
+### Step 2: Discover Environment
+
+When the domain requires system facts (network, devices, APIs, installed tools), use exec to discover real values. NEVER guess or fabricate system details — IPs, network ranges, service availability, installed software. Always verify.
+
+  # Network range
+  ifconfig | grep "inet "
+  # Installed tools
+  which nmap python3 mosquitto curl
+  # Reachable services
+  curl -s http://homeassistant.local:8123/api/ 2>/dev/null && echo "reachable"
+
+Include discovered facts in AGENTS.md so the agent has real environment data.
+
+### Step 3: Create Workspace + All Files
+
+  mkdir -p ~/.openclaw/workspace-{agentId}
+
+Write ALL workspace files:
+
+1. **AGENTS.md** — domain logic, schemas, environment. See "Writing AGENTS.md" below.
+2. **SOUL.md** — one short paragraph: how the agent speaks. Not what it does.
+   Good: "Precise and minimal. Confirm actions in one line. Match the user's language."
+   Bad: "Device discovery: 1. Check devices.json 2. Run discover.py" — operational, belongs in AGENTS.md.
+3. **IDENTITY.md** — fill in the agent's identity:
+   \`\`\`
+   # IDENTITY.md — {Agent Name}
+   - **Agent ID:** {agentId}
+   - **Name:** {Display Name}
+   - **Emoji:** {emoji}
+   - **Vibe:** {how the agent comes across — sharp? warm? philosophical? precise?}
+   - **Avatar:** {path if provided, otherwise omit}
+   \`\`\`
+4. **USER.md** — domain-specific user info. Only include facts relevant to THIS agent's domain:
+   \`\`\`
+   # USER.md — About ACV
+   - **Name:** Alberto (ACV)
+   - **Timezone:** Europe/Madrid
+   - **Language:** Spanish or English — match their language
+   ## {Domain}-Specific Context
+   {Relevant user facts for this domain}
+   \`\`\`
+   If the domain doesn't need user-specific facts, write a minimal USER.md with just name/timezone/language.
+5. **HEARTBEAT.md** — if the agent needs periodic checks, list them. Otherwise write an empty placeholder:
+   \`\`\`
+   # HEARTBEAT.md
+   # Keep empty to skip heartbeat checks.
+   \`\`\`
+
+### Step 4: Create Scripts (if needed)
+
+If the domain needs automation scripts:
+1. Write the script, then **test it with exec** — run it and verify output before moving on.
+2. Config data (scenes, endpoints, device lists) lives in data files (JSON), not hardcoded in scripts AND AGENTS.md. Single source of truth.
+3. Verify dependencies: \`which nmap\`, \`python3 -c "import json"\`.
+
+### Step 5: Register the Agent
+
+Call gateway tool with method "agentlife.createAgent":
+\`\`\`json
+{"id": "{agentId}", "name": "Display Name", "model": "{model}", "workspace": "/full/path", "description": "One sentence — specific domains, actions, data types.", "tools": {"profile": "full"}, "identity": {"name": "Display Name", "emoji": "{emoji}"}}
+\`\`\`
+
+Use $HOME, not ~. Description is critical — the orchestrator routes by it.
+
+**tools config:**
+- \`{"profile": "full"}\` — agent gets all tools (web_search, exec, read, write, agentlife_push, etc.). Use for agents that need web research, script execution, or file operations.
+- \`{"allow": ["agentlife_push"]}\` — restricted to specific tools only. Use for lightweight agents that only push widgets.
+- If the agent needs exec (scripts, image generation), web_search (research), or write (file operations), it MUST have \`profile: "full"\`.
+
+**identity config:** Sets the agent's display name and emoji in the platform UI. Match what you wrote in IDENTITY.md.
+
+### Step 6: Confirm via Widget
+
+Push a confirmation widget that seeds the agent's first context:
+
+\`\`\`
+surface agent-created size=m
+  card
+    column
+      text "{Agent Name} is ready" h3
+      text "Model: {model} · ID: {agentId}" caption
+      button "Try it now" action=try-agent primary
+goal: User sends first request to this agent
+detail: Created agent "{agentId}" for {domain}. The orchestrator will route matching requests here.
+followup: +1h "Check if user has sent a request. If not, push a proactive suggestion based on the domain."
+context: {"agentId":"{agentId}","domain":"{domain}","tables":[list of created tables],"environment":{discovered facts},"status":"ready"}
+\`\`\`
+
+## Writing AGENTS.md
+
+Required sections:
+- **Role** — what the agent does and doesn't do
+- **Boundaries** — explicit scope limits
+- **Environment** — real system facts discovered in Step 2 (IPs, paths, endpoints, available tools)
+- **Knowledge Strategy** — what goes in context: vs agentlife.db for this domain (see below)
+- **Data Schema** — CREATE TABLE IF NOT EXISTS statements (agent self-initializes on first use)
+- **Followup Strategy** — domain-specific check patterns, intervals, deletion triggers
+- **Goal Patterns** — typical goal: values (concrete, verifiable outcomes)
+- **Proactive Triggers** — what to discover autonomously, when to delegate
+- **Approval Patterns** — which actions need user approval
+- **Widget Structure** — what the face shows (metrics, badges, gauges for this domain)
+
+### Knowledge Strategy Section
+
+The platform already injects the general knowledge rules (context: vs agentlife.db vs what to avoid) via TOOLS.md. Do NOT repeat those rules in AGENTS.md.
+
+AGENTS.md should define the **domain-specific** storage mapping — what concrete data goes where for THIS agent:
+
+**context: fields for this domain** — list the specific keys:
+- Health: \`{"date","totals":{"kcal","protein","carbs","fat"},"lastEntry","activeGoals"}\`
+- Business: \`{"pipelineStage","kpis":{"mrr","churn","leads"},"pendingActions"}\`
+- Monitoring: \`{"knownDevices":[...],"lastScan","thresholds","infraPaths"}\`
+
+**agentlife.db tables for this domain** — reference the schemas from Step 5:
+- Health: meals, exercise_log, measurements — "query meals for today's totals, store in context:"
+- Business: contacts, deals, activities — "query deals by stage for pipeline widget"
+
+This tells the agent exactly which keys to write in context: and which tables to query — not the general rules about how context: works (the platform handles that).
+
+### Guidelines
+
+1. **Specific, not generic.** "Search flights on Google Flights" > "Help with travel."
+2. **Tool-first.** Write instructions around available tools, not abstract behaviors.
+3. **Real data.** Include IPs, paths, endpoints from Step 2 — never placeholders or guesses.
+4. **Error paths.** What happens when tools fail?
+5. **Concise but complete.** Cover the full domain — don't sacrifice completeness for brevity.
+
+## Registry Enrichment
+
+When you receive "Enrich agent registry descriptions" — system task, no widgets.
+
+For each agent: read workspace AGENTS.md + SOUL.md → write one-sentence description via agentlife.createAgent. Specific domains, actions, data types. Process all, respond "Done".
+
+## Deleting an Agent
+
+1. agentlife.deleteAgent: {"id": "{agentId}"}
+2. Optionally: exec rm -rf ~/.openclaw/workspace-{agentId}
+3. Push confirmation widget.
+
+## Improving Existing Agents
+
+1. Read ALL workspace files (AGENTS.md, SOUL.md, IDENTITY.md, USER.md, HEARTBEAT.md)
+2. Query agentlife.quality + agentlife.trace for actual quality issues
+3. Audit:
+   - **Workspace files complete?** All files present? IDENTITY.md filled in?
+   - **Config complete?** Agent has \`tools\` config? (\`profile: "full"\` or appropriate \`allow\` list)
+   - Knowledge strategy defined? (context: vs agentlife.db split)
+   - DB schema in AGENTS.md matches what the agent actually creates?
+   - Followup strategy domain-appropriate?
+   - Widget context quality — are agents writing complete snapshots?
+   - Environment facts still accurate? (re-discover if stale)
+   - Proactive behaviors producing value?
+4. Targeted edits — don't rewrite unless fundamentally broken
+5. Write updated files back. If missing workspace files, create them.
+6. If config is missing \`tools\`, call \`agentlife.createAgent\` with the existing id + the missing config fields (it patches existing agents).
+7. Show diff summary via widget
+
+## What You Are Not
+
+- Not an orchestrator — you don't route messages
+- Not a general assistant — only agent creation and improvement
+`;
+function buildPlatformSoulMd(userContent) {
+  const userSection = userContent.trim() ? `
+---
+
+## Personality
+
+${userContent.trim()}
+` : "";
+  return `# Agent Life Voice
+
+Your personality shows in widget detail: sections — that is where your voice lives. The widget face is data-driven and impersonal.
+${userSection}`;
+}
+
+// provisioning.ts
+var PROVISIONED_AGENTS = [
+  {
+    id: "agentlife",
+    name: "AgentLife",
+    isDefault: true,
+    agentsMd: ORCHESTRATOR_AGENTS_MD,
+    subagents: { allowAgents: ["*"] },
+    tools: {
+      allow: ["sessions_send", "sessions_list", "read", "memory_search", "memory_get", "agents_list"]
+    }
+  },
+  {
+    id: "quick",
+    name: "Quick",
+    agentsMd: QUICK_AGENTS_MD
+  },
+  {
+    id: "agentlife-builder",
+    name: "AgentLife Builder",
+    agentsMd: BUILDER_AGENTS_MD
+  }
+];
+function scheduleEnrichment(state, runtime, targets, log) {
+  if (!runtime.system?.runCommandWithTimeout) {
+    log("[agentlife] enrichment skipped — runtime.system not available");
+    return;
+  }
+  const run = runtime.system.runCommandWithTimeout;
+  setTimeout(async () => {
+    log(`[agentlife] starting registry enrichment for ${targets.length} agents`);
+    const promises = targets.map(async (t) => {
+      const msg = [
+        `Write a one-sentence description for agent "${t.name}" (id: ${t.id}).`,
+        `The description must capture what domains/topics the agent handles and what actions it performs.`,
+        `Reply with ONLY the description sentence — no preamble, no quotes, no explanation.`,
+        ``,
+        `SOUL.md:`,
+        "```",
+        t.soulMd || "(empty)",
+        "```",
+        ``,
+        `AGENTS.md:`,
+        "```",
+        t.agentsMd || "(empty)",
+        "```"
+      ].join(`
+`);
+      try {
+        const result = await run(["openclaw", "agent", "--agent", "agentlife-builder", "--message", msg, "--json"], { timeoutMs: 60000 });
+        const stdout = result?.stdout ?? "";
+        let description = "";
+        try {
+          const json = JSON.parse(stdout);
+          const payloads = json?.result?.payloads;
+          if (Array.isArray(payloads)) {
+            description = payloads.map((p) => p.text ?? "").join(" ").trim();
+          }
+        } catch {}
+        if (description && isUsableDescription(description, t.id, t.name)) {
+          state.agentRegistry.set(t.id, {
+            name: t.name,
+            description,
+            model: t.model,
+            createdAt: state.agentRegistry.get(t.id)?.createdAt ?? Date.now()
+          });
+          await saveRegistryToDisk(state);
+          log(`[agentlife] enriched ${t.id}: ${description}`);
+        } else {
+          log(`[agentlife] enrichment for ${t.id} produced unusable description: ${description || "(empty)"}`);
+        }
+      } catch (err) {
+        log(`[agentlife] enrichment failed for ${t.id} (non-critical): ${err?.message}`);
+      }
+    });
+    await Promise.all(promises);
+    log("[agentlife] enrichment complete");
+  }, 5000);
+}
+async function provisionAgents(state, cfg, runtime, log) {
+  const home = os.homedir();
+  const currentList = [...cfg.agents?.list ?? []];
+  let configChanged = false;
+  for (const agent of PROVISIONED_AGENTS) {
+    const workspaceDir = agent.workspaceDir ?? path3.join(home, ".openclaw", `workspace-${agent.id}`);
+    await fs2.mkdir(workspaceDir, { recursive: true });
+    await fs2.writeFile(path3.join(workspaceDir, "AGENTS.md"), agent.agentsMd, "utf-8");
+    if (!agent.existingAgent) {
+      const stubPath = path3.join(workspaceDir, "SOUL.md");
+      await fs2.writeFile(stubPath, "", { encoding: "utf-8", flag: "wx" }).catch(() => {});
+    }
+    if (agent.existingAgent)
+      continue;
+    const exists = currentList.some((a) => a.id === agent.id);
+    if (!exists) {
+      const entry = {
+        id: agent.id,
+        name: agent.name,
+        workspace: workspaceDir
+      };
+      if (agent.isDefault)
+        entry.default = true;
+      if (agent.subagents)
+        entry.subagents = agent.subagents;
+      if (agent.tools)
+        entry.tools = agent.tools;
+      if (agent.isDefault) {
+        currentList.unshift(entry);
+      } else {
+        currentList.push(entry);
+      }
+      configChanged = true;
+      log(`[agentlife] provisioned agent: ${agent.id}`);
+    } else if (agent.tools) {
+      const existing = currentList.find((a) => a.id === agent.id);
+      if (existing) {
+        const currentAllow = existing.tools?.allow;
+        const wantAllow = agent.tools.allow;
+        const needsUpdate = !currentAllow || currentAllow.length !== wantAllow?.length || !wantAllow?.every((t) => currentAllow.includes(t));
+        if (needsUpdate) {
+          existing.tools = agent.tools;
+          configChanged = true;
+          log(`[agentlife] updated tool restrictions for ${agent.id}`);
+        }
+      }
+    }
+  }
+  if (configChanged) {
+    const updatedCfg = {
+      ...cfg,
+      agents: {
+        ...cfg.agents,
+        list: currentList
+      }
+    };
+    await runtime.config.writeConfigFile(updatedCfg);
+    log("[agentlife] config updated with provisioned agents");
+  }
+  const SKIP_IDS = new Set(PROVISIONED_AGENTS.filter((a) => !a.existingAgent).map((a) => a.id));
+  const finalList = runtime.config.loadConfig().agents?.list ?? currentList;
+  const configIds = new Set(finalList.map((a) => a?.id).filter(Boolean));
+  let seeded = 0;
+  let pruned = 0;
+  for (const id of state.agentRegistry.keys()) {
+    if (SKIP_IDS.has(id))
+      continue;
+    if (!configIds.has(id)) {
+      state.agentRegistry.delete(id);
+      pruned++;
+    }
+  }
+  for (const agent of finalList) {
+    const id = agent?.id;
+    if (!id || SKIP_IDS.has(id) || state.agentRegistry.has(id))
+      continue;
+    const name = agent.name || id;
+    state.agentRegistry.set(id, {
+      name,
+      description: name,
+      model: agent.model || undefined,
+      createdAt: Date.now(),
+      needsEnrichment: true
+    });
+    seeded++;
+  }
+  if (seeded > 0 || pruned > 0) {
+    await saveRegistryToDisk(state);
+    if (seeded > 0)
+      log(`[agentlife] seeded registry with ${seeded} existing agents`);
+    if (pruned > 0)
+      log(`[agentlife] pruned ${pruned} stale agents from registry`);
+  }
+  const enrichTargets = [];
+  for (const [id, entry] of state.agentRegistry.entries()) {
+    if (!entry.needsEnrichment)
+      continue;
+    const agent = finalList.find((a) => a?.id === id);
+    const workspace = agent?.workspace || "";
+    let soulMd = "";
+    let agentsMd = "";
+    if (workspace) {
+      try {
+        soulMd = await fs2.readFile(path3.join(workspace, "SOUL.md"), "utf-8");
+      } catch {}
+      try {
+        agentsMd = await fs2.readFile(path3.join(workspace, "AGENTS.md"), "utf-8");
+      } catch {}
+    }
+    enrichTargets.push({ id, name: entry.name, workspace, model: entry.model, soulMd, agentsMd });
+  }
+  if (enrichTargets.length > 0) {
+    scheduleEnrichment(state, runtime, enrichTargets, log);
+  }
+  log("[agentlife] agent provisioning complete");
+}
+
+// services/surfaces-init.ts
+import * as path4 from "node:path";
+
+// activity.ts
+function recordSurfaceEvent(state, surfaceId, event, dsl, agentId, metadata) {
+  try {
+    getOrCreateHistoryDb(state).prepare("INSERT INTO surface_events (surfaceId,agentId,event,dsl,metadata,createdAt) VALUES (?,?,?,?,?,?)").run(surfaceId, agentId ?? null, event, dsl ?? null, metadata ?? null, Date.now());
+  } catch (err) {
+    console.warn("[agentlife] failed to record surface event:", err?.message);
+  }
+}
+function recordActivity(state, event, sessionKey, agentId, opts) {
+  try {
+    getOrCreateHistoryDb(state).prepare("INSERT INTO activity_log (ts,sessionKey,agentId,event,toolName,summary,data,runId) VALUES (?,?,?,?,?,?,?,?)").run(Date.now(), sessionKey ?? null, agentId ?? null, event, opts?.toolName ?? null, opts?.summary ?? null, opts?.data ?? null, opts?.runId ?? null);
+  } catch (err) {
+    console.warn("[agentlife] failed to record activity:", err?.message);
+  }
+}
+function summarizeParams(params) {
+  if (!params)
+    return null;
+  const filePath = params.file_path ?? params.path;
+  if (typeof filePath === "string")
+    return filePath;
+  const command = params.command;
+  if (typeof command === "string")
+    return command.slice(0, 200);
+  const pattern = params.pattern;
+  if (typeof pattern === "string")
+    return pattern;
+  const url = params.url;
+  if (typeof url === "string")
+    return url;
+  const query = params.query;
+  if (typeof query === "string")
+    return query;
+  const action = params.action;
+  if (typeof action === "string")
+    return action;
+  return null;
+}
+function registerAutomation(state, surfaceId, agentId, type, name, automationPath) {
+  const db = getOrCreateHistoryDb(state);
+  const now = Date.now();
+  let existing = null;
+  if (surfaceId) {
+    existing = db.prepare("SELECT id FROM automations WHERE surfaceId = ? AND path = ? AND status != 'removed'").get(surfaceId, automationPath);
+  }
+  if (!existing && agentId) {
+    existing = db.prepare("SELECT id FROM automations WHERE agentId = ? AND path = ? AND status != 'removed'").get(agentId, automationPath);
+  }
+  if (existing) {
+    db.prepare("UPDATE automations SET surfaceId = ?, agentId = ?, type = ?, name = ?, status = 'running', updatedAt = ? WHERE id = ?").run(surfaceId, agentId, type, name, now, existing.id);
+    return existing.id;
+  }
+  const result = db.prepare("INSERT INTO automations (surfaceId, agentId, type, name, path, status, createdAt, updatedAt) VALUES (?, ?, ?, ?, ?, 'running', ?, ?)").run(surfaceId, agentId, type, name, automationPath, now, now);
+  return Number(result.lastInsertRowid);
+}
+function autoRegisterInfraFromContext(state, surfaceId, agentId, context) {
+  const infra = context.infra;
+  if (!Array.isArray(infra))
+    return;
+  for (const item of infra) {
+    if (typeof item !== "object" || !item)
+      continue;
+    const type = typeof item.type === "string" ? item.type : "";
+    const itemPath = typeof item.path === "string" ? item.path : "";
+    if (!type || !itemPath)
+      continue;
+    const name = typeof item.name === "string" ? item.name : `${type} for ${surfaceId}`;
+    registerAutomation(state, surfaceId, agentId, type, name, itemPath);
+  }
+}
+
+// dashboard-state.ts
+function extractTitleAndDetail(meta) {
+  let title = null;
+  let detail = null;
+  const fullText = meta.lines.join(`
+`);
+  const titleMatch = fullText.match(/text\s+"([^"]+)"\s+h[34]/);
+  if (titleMatch)
+    title = titleMatch[1];
+  if (!title) {
+    const bodyMatch = fullText.match(/text\s+"([^"]+)"/);
+    if (bodyMatch)
+      title = bodyMatch[1];
+  }
+  const inlineDetail = fullText.match(/^\s*detail:\s*(.+)/m);
+  if (inlineDetail && inlineDetail[1].trim().length > 0) {
+    detail = inlineDetail[1].trim().replace(/^"|"$/g, "");
+  } else {
+    const detailBlockMatch = fullText.match(/^\s*detail:\s*\n((?:\s+.+\n?)+)/m);
+    if (detailBlockMatch) {
+      detail = detailBlockMatch[1].replace(/^ {2,4}/gm, "").trim();
+    }
+  }
+  return { title, detail };
+}
+function buildDashboardStateContext(state, agentId) {
+  if (!state.surfaceDb)
+    return null;
+  const now = Date.now();
+  let engagementMap = new Map;
+  try {
+    const db = getOrCreateHistoryDb(state);
+    const rows = db.prepare(`
+      SELECT surfaceId,
+        SUM(CASE WHEN event = 'detail_viewed' THEN 1 ELSE 0 END) as viewCount,
+        MAX(CASE WHEN event = 'detail_viewed' THEN createdAt ELSE 0 END) as lastViewedAt
+      FROM surface_events
+      WHERE event IN ('detail_viewed', 'action_clicked')
+      GROUP BY surfaceId
+    `).all();
+    for (const row of rows) {
+      engagementMap.set(row.surfaceId, { viewed: row.viewCount, lastViewedAt: row.lastViewedAt });
+    }
+  } catch {}
+  const cronInfo = new Map;
+  for (const [surfaceId, meta] of state.surfaceDb.entries()) {
+    if (meta.cronId && meta.followup) {
+      cronInfo.set(surfaceId, { cronId: meta.cronId, followup: meta.followup });
+    }
+  }
+  let hasActiveSurfaces = false;
+  for (const [, meta] of state.surfaceDb.entries()) {
+    if (!isExpired(meta, now)) {
+      hasActiveSurfaces = true;
+      break;
+    }
+  }
+  if (state.surfaceDb.size === 0 || !hasActiveSurfaces) {
+    let result2 = `## Dashboard is Empty
+
+No active widgets. Wait for user input.
+`;
+    if (state.surfaceDb.size > 0) {
+      const expiredEntries2 = [];
+      for (const [surfaceId, meta] of state.surfaceDb.entries()) {
+        const { title } = extractTitleAndDetail(meta);
+        if (isExpired(meta, now) && !meta.expiredSince) {
+          meta.expiredSince = now;
+        }
+        expiredEntries2.push(`[${surfaceId}] ${title ?? surfaceId} (updated ${formatAge(now - meta.updatedAt)}, EXPIRED)`);
+      }
+      if (expiredEntries2.length > 0) {
+        result2 += `
+### Recently Expired
+
+${expiredEntries2.join(`
+`)}`;
+      }
+    }
+    return result2;
+  }
+  const priorityOrder = { high: 0, normal: 1, low: 2 };
+  const activeEntries = [];
+  const expiredEntries = [];
+  const isOrchestrator = agentId === "agentlife";
+  for (const [surfaceId, meta] of state.surfaceDb.entries()) {
+    const expired = isExpired(meta, now);
+    if (expired && !meta.expiredSince) {
+      meta.expiredSince = now;
+    }
+    const owner = state.surfaceDb.getAgentId(surfaceId);
+    const isOwnWidget = !agentId || owner === agentId;
+    const { title } = extractTitleAndDetail(meta);
+    const label = title ?? surfaceId;
+    const age = formatAge(now - meta.updatedAt);
+    const headerLine = meta.lines[0] ?? "";
+    const isOverlay = /\boverlay\b/.test(headerLine);
+    const sizeMatch = headerLine.match(/\bsize=(\w+)/);
+    const priorityMatch = headerLine.match(/\bpriority=(\w+)/);
+    const priority = priorityOrder[priorityMatch?.[1] ?? "normal"] ?? 1;
+    const parts = [];
+    if (isOverlay)
+      parts.push("OVERLAY — user is seeing this right now");
+    if (owner)
+      parts.push(`by ${owner}`);
+    if (sizeMatch)
+      parts.push(`size=${sizeMatch[1]}`);
+    if (meta.goal)
+      parts.push(`goal: "${meta.goal}"`);
+    parts.push(`updated ${age}`);
+    const cron = cronInfo.get(surfaceId);
+    if (cron) {
+      parts.push(`followup: ${meta.followup} (cronId: ${cron.cronId})`);
+    } else if (meta.followup) {
+      parts.push(`followup: ${meta.followup} (pending)`);
+    } else {
+      parts.push("no followup");
+    }
+    if (meta.state && meta.state !== "active") {
+      parts.push(`state=${meta.state}`);
+    }
+    if (expired) {
+      parts.push("EXPIRED");
+    }
+    const eng = engagementMap.get(surfaceId);
+    if (eng && eng.viewed > 0) {
+      parts.push(`viewed ${eng.viewed}x`);
+    } else {
+      parts.push("not viewed");
+    }
+    let contextLine = "";
+    if (meta.context && isOwnWidget && !isOrchestrator) {
+      contextLine = `
+  context: ${JSON.stringify(meta.context)}`;
+    }
+    const entry = `[${surfaceId}] ${label} (${parts.join(", ")})${contextLine}`;
+    if (expired) {
+      expiredEntries.push(entry);
+    } else {
+      activeEntries.push({ entry, priority, updatedAt: meta.updatedAt });
+    }
+  }
+  activeEntries.sort((a, b) => a.priority - b.priority || b.updatedAt - a.updatedAt);
+  if (activeEntries.length === 0 && expiredEntries.length === 0)
+    return null;
+  let result = `## Current Dashboard State
+
+Every widget on the user's dashboard, sorted by recency (most recently updated first). Do NOT create widgets that overlap with existing ones — update or skip instead.
+`;
+  if (activeEntries.length > 0) {
+    result += `
+### Active Widgets
+
+${activeEntries.map((e) => e.entry).join(`
+
+`)}`;
+  }
+  if (expiredEntries.length > 0) {
+    result += `
+
+### Expired (delete or refresh)
+
+${expiredEntries.join(`
+
+`)}`;
+  }
+  if (agentId) {
+    try {
+      const db = getOrCreateHistoryDb(state);
+      const sevenDaysAgo = now - 7 * 24 * 60 * 60 * 1000;
+      const stats = db.prepare(`
+        SELECT
+          SUM(CASE WHEN event = 'created' THEN 1 ELSE 0 END) as pushed,
+          SUM(CASE WHEN event = 'detail_viewed' THEN 1 ELSE 0 END) as viewed,
+          SUM(CASE WHEN event = 'dismissed' THEN 1 ELSE 0 END) as dismissed,
+          SUM(CASE WHEN event = 'expired' THEN 1 ELSE 0 END) as expired,
+          SUM(CASE WHEN event = 'quality_warning' THEN 1 ELSE 0 END) as warnings
+        FROM surface_events
+        WHERE agentId = ? AND createdAt > ?
+      `).get(agentId, sevenDaysAgo);
+      if (stats && (stats.pushed > 0 || stats.warnings > 0)) {
+        let perfLine = `Pushed: ${stats.pushed ?? 0} | Viewed: ${stats.viewed ?? 0} | Dismissed: ${stats.dismissed ?? 0} | Expired: ${stats.expired ?? 0} | Quality warnings: ${stats.warnings ?? 0}`;
+        if ((stats.dismissed ?? 0) > 0) {
+          try {
+            const reasons = db.prepare(`
+              SELECT
+                json_extract(metadata, '$.reason') as reason,
+                COUNT(*) as cnt
+              FROM surface_events
+              WHERE agentId = ? AND event = 'dismissed' AND metadata IS NOT NULL AND createdAt > ?
+              GROUP BY reason ORDER BY cnt DESC
+            `).all(agentId, sevenDaysAgo);
+            if (reasons?.length > 0) {
+              const reasonParts = reasons.map((r) => `${r.reason ?? "unknown"}: ${r.cnt}`);
+              perfLine += `
+Dismiss reasons: ${reasonParts.join(", ")}`;
+            }
+          } catch {}
+        }
+        result += `
+
+## Your Performance (7 days)
+${perfLine}`;
+      }
+    } catch {}
+  }
+  if (agentId) {
+    try {
+      const db = getOrCreateHistoryDb(state);
+      const autos = db.prepare("SELECT * FROM automations WHERE agentId = ? AND status != 'removed' ORDER BY updatedAt DESC").all(agentId);
+      if (autos.length > 0) {
+        const autoLines = autos.map((a) => {
+          const widgetRef = a.surfaceId ? `, widget=${a.surfaceId}` : "";
+          const statusTag = a.status !== "running" ? ` STATUS: ${a.status.toUpperCase()}` : "";
+          return `[auto:${a.id}] ${a.name} (type=${a.type}, path=${a.path}${widgetRef}, ${a.status}${statusTag})`;
+        });
+        result += `
+
+### Your Automations
+
+${autoLines.join(`
+`)}`;
+      }
+      const orphaned = autos.filter((a) => a.surfaceId && !state.surfaceDb.has(a.surfaceId) && a.status === "running");
+      if (orphaned.length > 0) {
+        const orphanLines = orphaned.map((a) => `[auto:${a.id}] ${a.name} (type=${a.type}, path=${a.path}, was widget=${a.surfaceId})`);
+        result += `
+
+### Orphaned Automations (widget dismissed, still running)
+
+${orphanLines.join(`
+`)}`;
+      }
+    } catch {}
+  }
+  if (state.agentRegistry.size > 0) {
+    const registryLines = [];
+    for (const [id, entry] of state.agentRegistry.entries()) {
+      registryLines.push(`- ${entry.name} (id: ${id}) — ${entry.description}`);
+    }
+    result += `
+
+## Available Agents
+
+${registryLines.join(`
+`)}`;
+  }
+  return result;
+}
+
+// followup.ts
+var pollerInterval = null;
+function initFollowupSystem(api, state) {
+  if (!state.runCommand) {
+    console.warn("[agentlife:followup] runCommand not available — followups will not fire");
+    return;
+  }
+  const sys = api.runtime?.system;
+  if (sys?.enqueueSystemEvent)
+    state.enqueueSystemEvent = sys.enqueueSystemEvent;
+  if (sys?.requestHeartbeatNow)
+    state.requestHeartbeatNow = sys.requestHeartbeatNow;
+  const db = getOrCreateHistoryDb(state);
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS followups (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      surfaceId TEXT NOT NULL,
+      agentId TEXT,
+      fireAt INTEGER NOT NULL,
+      instruction TEXT NOT NULL,
+      status TEXT NOT NULL DEFAULT 'pending',
+      createdAt INTEGER NOT NULL
+    );
+    CREATE INDEX IF NOT EXISTS idx_followups_fire ON followups(fireAt);
+    CREATE INDEX IF NOT EXISTS idx_followups_surface ON followups(surfaceId);
+    CREATE INDEX IF NOT EXISTS idx_followups_status ON followups(status);
+  `);
+  pollerInterval = setInterval(() => pollFollowups(state), 60000);
+  setTimeout(() => pollFollowups(state), 5000);
+  console.log("[agentlife:followup] system initialized — polling every 60s");
+}
+function stopFollowupSystem() {
+  if (pollerInterval) {
+    clearInterval(pollerInterval);
+    pollerInterval = null;
+  }
+}
+function parseFollowup(raw) {
+  const match = raw.match(/^(\+\d+(?:ms|s|m|h|d))\s+(.+)/);
+  if (!match)
+    return null;
+  return {
+    timeOffset: match[1],
+    message: match[2].replace(/^"|"$/g, "").trim()
+  };
+}
+function scheduleFollowup(state, surfaceId, followupRaw, agentId) {
+  const parsed = parseFollowup(followupRaw);
+  if (!parsed) {
+    console.warn("[agentlife:followup] parse failed for %s: %s", surfaceId, followupRaw);
+    return;
+  }
+  const existing = state.pendingFollowups.get(surfaceId);
+  if (existing)
+    clearTimeout(existing);
+  state.pendingFollowups.set(surfaceId, setTimeout(() => {
+    state.pendingFollowups.delete(surfaceId);
+    executeSchedule(state, surfaceId, parsed, agentId);
+  }, 2000));
+}
+function removeFollowup(state, surfaceId) {
+  const pending = state.pendingFollowups.get(surfaceId);
+  if (pending) {
+    clearTimeout(pending);
+    state.pendingFollowups.delete(surfaceId);
+  }
+  try {
+    const db = getOrCreateHistoryDb(state);
+    const result = db.prepare("UPDATE followups SET status = 'cancelled' WHERE surfaceId = ? AND status = 'pending'").run(surfaceId);
+    if (result.changes > 0) {
+      console.log("[agentlife:followup] cancelled %d pending followup(s) for %s", result.changes, surfaceId);
+    }
+  } catch (e) {
+    console.warn("[agentlife:followup] cancel failed for %s: %s", surfaceId, e?.message);
+  }
+  state.surfaceDb?.setCronId(surfaceId, null);
+}
+function formatAge(ms) {
+  if (ms < 60000)
+    return "just now";
+  const minutes = Math.floor(ms / 60000);
+  if (minutes < 60)
+    return `${minutes}min ago`;
+  const hours = Math.floor(minutes / 60);
+  if (hours < 24)
+    return `${hours}h ago`;
+  const days = Math.floor(hours / 24);
+  return `${days}d ago`;
+}
+function parseOffset(offset) {
+  const match = offset.match(/^\+?(\d+)(ms|s|m|h|d)$/);
+  if (!match)
+    return 0;
+  const val = parseInt(match[1], 10);
+  switch (match[2]) {
+    case "ms":
+      return val;
+    case "s":
+      return val * 1000;
+    case "m":
+      return val * 60000;
+    case "h":
+      return val * 3600000;
+    case "d":
+      return val * 86400000;
+    default:
+      return 0;
+  }
+}
+function executeSchedule(state, surfaceId, parsed, agentId) {
+  const meta = state.surfaceDb?.get(surfaceId);
+  const goalText = meta?.goal ?? (meta ? extractTitleAndDetail(meta).title : null);
+  const goalLabel = goalText ? ` (goal: "${goalText}")` : "";
+  const instruction = [
+    `Widget followup for ${surfaceId}${goalLabel}: ${parsed.message}`,
+    `Check your dashboard state for engagement. Update widget state. Advance the work or delete the widget.`
+  ].join(`
+`);
+  const fireAt = Date.now() + parseOffset(parsed.timeOffset);
+  try {
+    const db = getOrCreateHistoryDb(state);
+    db.prepare("UPDATE followups SET status = 'cancelled' WHERE surfaceId = ? AND status = 'pending'").run(surfaceId);
+    const result = db.prepare("INSERT INTO followups (surfaceId, agentId, fireAt, instruction, status, createdAt) VALUES (?, ?, ?, ?, 'pending', ?)").run(surfaceId, agentId, fireAt, instruction, Date.now());
+    const followupId = result.lastInsertRowid;
+    state.surfaceDb?.setCronId(surfaceId, String(followupId));
+    recordSurfaceEvent(state, surfaceId, "cron_scheduled", undefined, agentId ?? undefined, JSON.stringify({ followupId, timeOffset: parsed.timeOffset, message: parsed.message }));
+    console.log("[agentlife:followup] scheduled %s: fires in %s (%s)", surfaceId, parsed.timeOffset, parsed.message);
+  } catch (e) {
+    console.error("[agentlife:followup] schedule failed for %s: %s", surfaceId, e?.message);
+    recordSurfaceEvent(state, surfaceId, "cron_failed", undefined, agentId ?? undefined, JSON.stringify({ error: e?.message, timeOffset: parsed.timeOffset }));
+  }
+}
+function pollFollowups(state) {
+  if (state.disabled || !state.runCommand)
+    return;
+  try {
+    const db = getOrCreateHistoryDb(state);
+    const now = Date.now();
+    const due = db.prepare("SELECT id, surfaceId, agentId, instruction FROM followups WHERE status = 'pending' AND fireAt <= ? ORDER BY fireAt ASC").all(now);
+    for (const row of due) {
+      db.prepare("UPDATE followups SET status = 'fired' WHERE id = ?").run(row.id);
+      const meta = state.surfaceDb?.get(row.surfaceId);
+      if (!meta || meta.state === "terminal" || meta.state === "dismissed") {
+        console.log("[agentlife:followup] skipped %s — surface gone or terminal", row.surfaceId);
+        continue;
+      }
+      const agentId = row.agentId ?? state.surfaceDb?.getAgentId(row.surfaceId) ?? null;
+      if (!agentId) {
+        console.warn("[agentlife:followup] skipped %s — no agentId", row.surfaceId);
+        continue;
+      }
+      const sessionKey = `agent:${agentId}:main`;
+      const idempotencyKey = `followup-${row.surfaceId}-${Date.now()}`;
+      const chatParams = JSON.stringify({ sessionKey, message: `[system] ${row.instruction}`, idempotencyKey });
+      state.runCommand(["openclaw", "gateway", "call", "chat.send", "--params", chatParams], { timeoutMs: 60000 }).then((result) => {
+        console.log("[agentlife:followup] chat.send for %s: code=%s", row.surfaceId, result?.code ?? "?");
+      }).catch((e) => {
+        console.error("[agentlife:followup] chat.send failed for %s: %s", row.surfaceId, e?.message);
+      });
+      recordSurfaceEvent(state, row.surfaceId, "cron_fired", undefined, agentId);
+      console.log("[agentlife:followup] fired %s → %s", row.surfaceId, sessionKey);
+    }
+  } catch (e) {
+    console.warn("[agentlife:followup] poll error: %s", e?.message);
+  }
+}
+
+// surfaces.ts
+var DEFAULT_CEILING_MS = 7 * 24 * 60 * 60 * 1000;
+var NO_FOLLOWUP_CEILING_MS = 48 * 60 * 60 * 1000;
+var OVERLAY_TTL_MS = 30 * 60 * 1000;
+var GRACE_PERIOD_MS = 24 * 60 * 60 * 1000;
+function isExpired(meta, now = Date.now()) {
+  if (meta.state === "terminal")
+    return false;
+  const isInput = meta.lines.some((l) => /^surface\s+\S+.*\binput\b/.test(l.trim()));
+  if (isInput)
+    return false;
+  const isOverlay = meta.lines.some((l) => /^surface\s+\S+.*\boverlay\b/.test(l.trim()));
+  if (isOverlay && now - meta.updatedAt > OVERLAY_TTL_MS)
+    return true;
+  if (!meta.followup && now - meta.updatedAt > NO_FOLLOWUP_CEILING_MS)
+    return true;
+  if (now - meta.updatedAt > DEFAULT_CEILING_MS)
+    return true;
+  return false;
+}
+function isPastGrace(meta, now = Date.now()) {
+  return !!meta.expiredSince && now - meta.expiredSince > GRACE_PERIOD_MS;
+}
+function processDslBlock(state, dsl) {
+  if (!state.surfaceDb)
+    return [];
+  const now = Date.now();
+  const results = [];
+  const blocks = dsl.split(/\n---(?:\n|$)/).filter((b) => b.trim().length > 0);
+  for (const block of blocks) {
+    const firstLine = block.trim().split(`
+`)[0]?.trim() ?? "";
+    if (firstLine.startsWith("delete ")) {
+      const sid2 = firstLine.slice(7).trim();
+      if (sid2) {
+        state.surfaceDb.delete(sid2);
+        recordSurfaceEvent(state, sid2, "deleted");
+        results.push({ surfaceId: sid2, isNew: false, followupChanged: false, followupRemoved: false, stateTransition: null });
+      }
+      continue;
+    }
+    const surfaceMatch = block.match(/^surface\s+(\S+)/m);
+    if (!surfaceMatch)
+      continue;
+    const sid = surfaceMatch[1];
+    const headerLine = block.match(/^surface\s+.*/m)?.[0] ?? "";
+    const isOverlay = /\boverlay\b/.test(headerLine);
+    const isInput = /\binput\b/.test(headerLine);
+    const stateMatch = headerLine.match(/\bstate=(\w+)\b/);
+    const declaredState = stateMatch?.[1] ?? null;
+    const followupMatch = block.match(/^\s*followup:\s*(.+)/m);
+    const goalMatch = block.match(/^\s*goal:\s*(.+)/m);
+    const contextMatch = block.match(/^\s*context:\s*(.+)/m);
+    let parsedContext;
+    if (contextMatch) {
+      try {
+        const parsed = JSON.parse(contextMatch[1].trim());
+        if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) {
+          parsedContext = parsed;
+        } else {
+          console.warn("[agentlife] context: must be a JSON object — skipping");
+        }
+      } catch (err) {
+        console.warn("[agentlife] malformed context: JSON — %s", err?.message);
+      }
+    }
+    const hasTransientState = /\bstate=(loading|dismissing)\b/.test(headerLine);
+    const cleanedBlock = hasTransientState ? block.replace(/\bstate=(loading|dismissing)\b/, "") : block;
+    const cleanedLines = cleanedBlock.split(`
+`).filter((line) => !/^\s*state\s*=\s*\w+\s*$/.test(line));
+    const existing = state.surfaceDb.get(sid);
+    const oldFollowup = existing?.followup;
+    const oldState = existing?.state ?? "active";
+    let newState;
+    if (declaredState === "terminal") {
+      newState = "terminal";
+    } else if (declaredState === "loading") {
+      newState = "loading";
+    } else if (!existing) {
+      newState = "active";
+    } else {
+      newState = oldState === "terminal" ? "terminal" : "active";
+    }
+    const newFollowup = followupMatch?.[1]?.trim();
+    let resolvedContext;
+    let contextDroppedFields;
+    if (parsedContext) {
+      resolvedContext = parsedContext;
+      if (existing?.context) {
+        const oldKeys = Object.keys(existing.context);
+        const newKeys = new Set(Object.keys(parsedContext));
+        contextDroppedFields = oldKeys.filter((k) => !newKeys.has(k));
+        if (contextDroppedFields.length === 0)
+          contextDroppedFields = undefined;
+      }
+    } else {
+      resolvedContext = existing?.context;
+    }
+    const newGoal = goalMatch?.[1]?.trim() ?? existing?.goal;
+    const goalChanged = existing?.goal && newGoal && goalMatch && existing.goal !== newGoal ? { from: existing.goal, to: newGoal } : undefined;
+    if (goalChanged) {
+      console.warn('[agentlife] %s: goal changed from "%s" to "%s" — consider using a new surfaceId for a new goal', sid, goalChanged.from, goalChanged.to);
+    }
+    const meta = {
+      lines: cleanedLines,
+      createdAt: existing?.createdAt ?? now,
+      updatedAt: now,
+      followup: newFollowup,
+      goal: newGoal,
+      context: resolvedContext,
+      expiredSince: undefined
+    };
+    state.surfaceDb.set(sid, meta);
+    state.surfaceDb.setState(sid, newState);
+    if (isOverlay || isInput) {
+      state.surfaceDb.setTransient(sid, true);
+    } else {
+      state.surfaceDb.setTransient(sid, false);
+    }
+    const followupChanged = oldFollowup !== newFollowup;
+    const followupRemoved = !!oldFollowup && !newFollowup;
+    const stateTransition = oldState !== newState ? `${oldState}->${newState}` : null;
+    results.push({ surfaceId: sid, isNew: !existing, followupChanged, followupRemoved, stateTransition, contextDroppedFields, goalChanged });
+    recordSurfaceEvent(state, sid, existing ? "updated" : "created", block, state.surfaceDb.getAgentId(sid));
+  }
+  return results;
+}
+function runStartupPurge(state) {
+  if (!state.surfaceDb)
+    return;
+  const now = Date.now();
+  let purged = 0;
+  for (const [surfaceId, meta] of state.surfaceDb.entries()) {
+    if (isPastGrace(meta, now)) {
+      const cronId = state.surfaceDb.getCronId(surfaceId);
+      state.surfaceDb.delete(surfaceId);
+      recordSurfaceEvent(state, surfaceId, "expired");
+      if (cronId) {
+        removeFollowup(state, surfaceId);
+      }
+      purged++;
+    } else if (isExpired(meta, now) && !meta.expiredSince) {
+      state.surfaceDb.set(surfaceId, { ...meta, expiredSince: now });
+    }
+  }
+  let backfilled = 0;
+  const orphanedIds = state.surfaceDb.keys().filter((id) => !state.surfaceDb.getAgentId(id));
+  if (orphanedIds.length > 0) {
+    try {
+      const db = getOrCreateHistoryDb(state);
+      for (const sid of orphanedIds) {
+        const row = db.prepare("SELECT agentId FROM surface_events WHERE surfaceId = ? AND agentId IS NOT NULL ORDER BY createdAt DESC LIMIT 1").get(sid);
+        if (row?.agentId) {
+          state.surfaceDb.setAgentId(sid, row.agentId);
+          backfilled++;
+        }
+      }
+    } catch {}
+  }
+  console.log("[agentlife] surfaces DB: %d persisted%s%s", state.surfaceDb.size, purged > 0 ? ` (purged ${purged} past grace period)` : "", backfilled > 0 ? ` (backfilled ${backfilled} agent mappings from history)` : "");
+}
+
+// cleanup.ts
+function enqueueCleanupTasks(state, surfaceId, agentId, cronId, automations) {
+  const db = getOrCreateHistoryDb(state);
+  const now = Date.now();
+  const insert = db.prepare(`INSERT INTO cleanup_tasks (surfaceId, agentId, step, status, attempts, maxAttempts, lastError, payload, createdAt, updatedAt)
+     VALUES (?, ?, ?, 'pending', 0, ?, NULL, ?, ?, ?)`);
+  if (cronId) {
+    insert.run(surfaceId, agentId, "cron_remove", 3, JSON.stringify({ cronId }), now, now);
+  }
+  if (agentId) {
+    insert.run(surfaceId, agentId, "agent_notify", 5, JSON.stringify({ agentId, automations }), now, now);
+  }
+}
+function resetInterruptedTasks(state) {
+  try {
+    const db = getOrCreateHistoryDb(state);
+    const result = db.prepare("UPDATE cleanup_tasks SET status = 'pending', updatedAt = ? WHERE status = 'running'").run(Date.now());
+    return result.changes;
+  } catch {
+    return 0;
+  }
+}
+async function processCleanupTasks(state, surfaceId) {
+  const db = getOrCreateHistoryDb(state);
+  const query = surfaceId ? db.prepare("SELECT * FROM cleanup_tasks WHERE status IN ('pending', 'failed') AND attempts < maxAttempts AND surfaceId = ? ORDER BY createdAt ASC") : db.prepare("SELECT * FROM cleanup_tasks WHERE status IN ('pending', 'failed') AND attempts < maxAttempts ORDER BY createdAt ASC");
+  const tasks = surfaceId ? query.all(surfaceId) : query.all();
+  if (tasks.length === 0)
+    return;
+  let hadFailures = false;
+  for (const task of tasks) {
+    const ok = await executeTask(state, db, task);
+    if (!ok)
+      hadFailures = true;
+  }
+  if (hadFailures) {
+    setTimeout(() => processCleanupTasks(state).catch(() => {}), 30000);
+  }
+}
+async function executeTask(state, db, task) {
+  const now = Date.now();
+  db.prepare("UPDATE cleanup_tasks SET status = 'running', attempts = attempts + 1, updatedAt = ? WHERE id = ?").run(now, task.id);
+  try {
+    const payload = task.payload ? JSON.parse(task.payload) : {};
+    switch (task.step) {
+      case "cron_remove":
+        await executeCronRemove(state, task.surfaceId, payload);
+        break;
+      case "agent_notify":
+        await executeAgentNotify(state, db, task.surfaceId, payload);
+        break;
+      default:
+        throw new Error(`unknown cleanup step: ${task.step}`);
+    }
+    db.prepare("UPDATE cleanup_tasks SET status = 'done', updatedAt = ? WHERE id = ?").run(Date.now(), task.id);
+    return true;
+  } catch (err) {
+    const msg = err?.message ?? String(err);
+    db.prepare("UPDATE cleanup_tasks SET status = 'failed', lastError = ?, updatedAt = ? WHERE id = ?").run(msg, Date.now(), task.id);
+    console.warn("[agentlife:cleanup] task %d (%s/%s) failed (attempt %d/%d): %s", task.id, task.surfaceId, task.step, task.attempts + 1, task.maxAttempts, msg);
+    return false;
+  }
+}
+async function executeCronRemove(state, surfaceId, _payload) {
+  removeFollowup(state, surfaceId);
+}
+async function executeAgentNotify(state, db, surfaceId, payload) {
+  if (!state.runCommand)
+    throw new Error("runCommand not available");
+  if (!payload.agentId)
+    return;
+  await state.runCommand([
+    "openclaw",
+    "agent",
+    "--agent",
+    payload.agentId,
+    "--message",
+    `[event:dismissed] surfaceId=${surfaceId}`,
+    "--json"
+  ], { timeoutMs: 60000 });
+  const automations = Array.isArray(payload.automations) ? payload.automations : [];
+  const ids = automations.map((a) => a.id).filter((id) => typeof id === "number");
+  if (ids.length > 0) {
+    const placeholders = ids.map(() => "?").join(",");
+    db.prepare(`UPDATE automations SET status = 'removed', updatedAt = ? WHERE id IN (${placeholders}) AND status != 'removed'`).run(Date.now(), ...ids);
+    console.log("[agentlife:cleanup] marked %d automations as removed for %s (agent notified)", ids.length, surfaceId);
+  }
+}
+
+// services/surfaces-init.ts
+function registerSurfacesService(api, state) {
+  api.registerService({
+    id: "agentlife-surfaces",
+    start: async (ctx) => {
+      const agentlifeDir = path4.join(ctx.stateDir, "agentlife");
+      state.agentlifeStateDir = agentlifeDir;
+      state.registryFilePath = path4.join(agentlifeDir, "agent-registry.json");
+      state.dbBaseDir = path4.join(agentlifeDir, "db");
+      state.historyDbPath = path4.join(agentlifeDir, "agentlife.db");
+      if (!state.surfaceDb) {
+        const db = getOrCreateHistoryDb(state);
+        state.surfaceDb = new SurfaceDb(db);
+      }
+      runStartupPurge(state);
+      let inputPurged = 0;
+      for (const [surfaceId, meta] of state.surfaceDb.entries()) {
+        const headerLine = meta.lines[0] ?? "";
+        if (/\binput\b/.test(headerLine)) {
+          state.surfaceDb.delete(surfaceId);
+          inputPurged++;
+        }
+      }
+      if (inputPurged > 0) {
+        console.log("[agentlife] purged %d stale input surfaces on startup", inputPurged);
+      }
+      await loadRegistryFromDisk(state);
+      console.log("[agentlife] surface persistence service started (SQLite: %s)", state.historyDbPath);
+      setTimeout(async () => {
+        try {
+          let rescued = 0;
+          const db = getOrCreateHistoryDb(state);
+          for (const [surfaceId, meta] of state.surfaceDb.entries()) {
+            if (meta.followup && meta.state === "active" && !isExpired(meta)) {
+              const pending = db.prepare("SELECT id FROM followups WHERE surfaceId = ? AND status = 'pending' LIMIT 1").get(surfaceId);
+              if (!pending) {
+                const agentId = state.surfaceDb.getAgentId(surfaceId) ?? null;
+                scheduleFollowup(state, surfaceId, meta.followup, agentId);
+                rescued++;
+              }
+            }
+          }
+          if (rescued > 0) {
+            console.log("[agentlife] followup reconciliation: %d orphaned followups rescued", rescued);
+          }
+          const runningAutos = db.prepare("SELECT id, surfaceId FROM automations WHERE status = 'running' AND surfaceId IS NOT NULL").all();
+          let autosOrphaned = 0;
+          for (const a of runningAutos) {
+            if (!state.surfaceDb.has(a.surfaceId)) {
+              db.prepare("UPDATE automations SET status = 'removed', updatedAt = ? WHERE id = ?").run(Date.now(), a.id);
+              autosOrphaned++;
+            }
+          }
+          if (autosOrphaned > 0) {
+            console.log("[agentlife] automation reconciliation: marked %d orphaned automations as removed", autosOrphaned);
+          }
+        } catch (err) {
+          console.warn("[agentlife] reconciliation failed (non-critical): %s", err?.message);
+        }
+        try {
+          const reset = resetInterruptedTasks(state);
+          if (reset > 0) {
+            console.log("[agentlife] cleanup reconciliation: reset %d interrupted tasks", reset);
+          }
+          await processCleanupTasks(state);
+        } catch (err) {
+          console.warn("[agentlife] cleanup reconciliation failed (non-critical): %s", err?.message);
+        }
+      }, 3000);
+    }
+  });
+}
+
+// services/config-optimizer.ts
+import * as fs3 from "node:fs/promises";
+import * as path5 from "node:path";
+async function restoreConfigFromBackup(api, backupPath) {
+  const raw = await fs3.readFile(backupPath, "utf-8");
+  const backup = JSON.parse(raw);
+  const liveCfg = api.runtime.config.loadConfig();
+  const restored = {
+    ...liveCfg,
+    session: {
+      ...liveCfg.session,
+      agentToAgent: {
+        ...liveCfg.session?.agentToAgent,
+        maxPingPongTurns: backup.maxPingPongTurns ?? undefined
+      }
+    }
+  };
+  await api.runtime.config.writeConfigFile(restored);
+  await fs3.unlink(backupPath);
+  const label = backup.maxPingPongTurns ?? "default";
+  console.log("[agentlife] restored config: maxPingPongTurns=%s", label);
+  return `maxPingPongTurns restored to ${label}`;
+}
+function registerConfigOptimizer(api, _state) {
+  api.registerService({
+    id: "agentlife-config-optimizer",
+    start: async (ctx) => {
+      const configBackupDir = path5.join(ctx.stateDir, "agentlife");
+      const configBackupPath = path5.join(configBackupDir, "config-backup.json");
+      const cfg = api.runtime.config.loadConfig();
+      const current = cfg.session?.agentToAgent?.maxPingPongTurns;
+      if (current === 1) {
+        console.log("[agentlife] config already optimized (maxPingPongTurns=1), skipping");
+        return;
+      }
+      await fs3.mkdir(configBackupDir, { recursive: true });
+      await fs3.writeFile(configBackupPath, JSON.stringify({ maxPingPongTurns: current ?? null }));
+      const next = {
+        ...cfg,
+        session: {
+          ...cfg.session,
+          agentToAgent: { ...cfg.session?.agentToAgent, maxPingPongTurns: 1 }
+        }
+      };
+      await api.runtime.config.writeConfigFile(next);
+      const verify = api.runtime.config.loadConfig();
+      const applied = verify.session?.agentToAgent?.maxPingPongTurns;
+      if (applied === 1) {
+        console.log("[agentlife] config optimized: maxPingPongTurns 1 (was %s)", current ?? "default");
+      } else {
+        console.error("[agentlife] config write FAILED — maxPingPongTurns is %s after write (expected 1)", applied);
+      }
+    },
+    stop: async (ctx) => {
+      try {
+        const backupPath = path5.join(ctx.stateDir, "agentlife", "config-backup.json");
+        await restoreConfigFromBackup(api, backupPath);
+      } catch {}
+    }
+  });
+}
+
+// services/pairing.ts
+import * as fsSync2 from "node:fs";
+import { createRequire as createRequire3 } from "node:module";
+import * as os2 from "node:os";
+import * as path6 from "node:path";
+function registerPairingServices(api) {
+  api.registerService({
+    id: "agentlife-pairing-qr",
+    start: async (_ctx) => {
+      try {
+        const cfg = api.runtime.config.loadConfig();
+        const bind = cfg.gateway?.bind ?? "loopback";
+        const port = cfg.gateway?.port ?? 18789;
+        const token = cfg.gateway?.auth?.token;
+        if (!token)
+          return;
+        let host;
+        if (bind === "lan" || bind === "auto" || bind === "custom") {
+          const nets = os2.networkInterfaces();
+          const lanIp = Object.values(nets).flat().find((n) => n && !n.internal && n.family === "IPv4")?.address;
+          host = lanIp ?? "127.0.0.1";
+        } else {
+          host = "127.0.0.1";
+        }
+        const payload = JSON.stringify({ url: `ws://${host}:${port}`, token });
+        const setupCode = Buffer.from(payload).toString("base64");
+        let qrTerminal = null;
+        try {
+          const realPath = fsSync2.realpathSync(process.argv[1] || "");
+          const mainRequire = createRequire3(realPath);
+          qrTerminal = mainRequire("qrcode-terminal");
+        } catch {}
+        console.log(`
+\x1B[36m[agentlife]\x1B[0m \x1B[1mPairing QR\x1B[0m`);
+        console.log(`Scan this with the Agent Life app to connect.
+`);
+        if (qrTerminal?.generate) {
+          qrTerminal.generate(setupCode, { small: true }, (qr) => {
+            console.log(qr);
+            console.log(`
+Setup code: ${setupCode}
+`);
+          });
+        } else {
+          console.log(`Setup code: ${setupCode}`);
+          console.log(`Run 'openclaw qr' for a scannable QR code.
+`);
+        }
+        console.log("  Download the app:");
+        console.log("    iOS:     https://agentlife.app/ios");
+        console.log("    Android: https://agentlife.app/android");
+        console.log("");
+      } catch (err) {
+        console.warn("[agentlife] QR generation skipped:", err?.message);
+      }
+    }
+  });
+  api.registerService({
+    id: "agentlife-auto-pair",
+    start: async (ctx) => {
+      const devicesDir = path6.join(os2.homedir(), ".openclaw", "devices");
+      const pendingPath = path6.join(devicesDir, "pending.json");
+      const pairedPath = path6.join(devicesDir, "paired.json");
+      const pollInterval = 3000;
+      const poll = () => {
+        try {
+          if (!fsSync2.existsSync(pendingPath))
+            return;
+          const pending = JSON.parse(fsSync2.readFileSync(pendingPath, "utf-8"));
+          const reqIds = Object.keys(pending);
+          if (!reqIds.length)
+            return;
+          const paired = fsSync2.existsSync(pairedPath) ? JSON.parse(fsSync2.readFileSync(pairedPath, "utf-8")) : {};
+          for (const reqId of reqIds) {
+            const req = pending[reqId];
+            paired[req.deviceId] = { ...req, approvedAtMs: Date.now() };
+            delete pending[reqId];
+            console.log("[agentlife] Auto-approved device: %s (%s)", req.deviceId?.slice(0, 16), req.platform || "?");
+          }
+          fsSync2.writeFileSync(pendingPath, JSON.stringify(pending, null, 2));
+          fsSync2.writeFileSync(pairedPath, JSON.stringify(paired, null, 2));
+        } catch (err) {
+          console.warn("[agentlife] Auto-pair poll error:", err?.message);
+        }
+      };
+      const timer = setInterval(poll, pollInterval);
+      setTimeout(poll, 2000);
+      if (typeof ctx.onStop === "function") {
+        ctx.onStop(() => clearInterval(timer));
+      }
+    }
+  });
+}
+
+// channel-guard.ts
+var CHANNEL_SEGMENTS = [
+  ":telegram:",
+  ":discord:",
+  ":whatsapp:",
+  ":slack:",
+  ":signal:",
+  ":irc:",
+  ":matrix:",
+  ":line:",
+  ":msteams:",
+  ":nostr:",
+  ":imessage:",
+  ":bluebubbles:",
+  ":googlechat:",
+  ":feishu:",
+  ":zalo:"
+];
+function isChannelSession(sessionKey) {
+  if (!sessionKey)
+    return false;
+  return CHANNEL_SEGMENTS.some((seg) => sessionKey.includes(seg));
+}
+
+// hooks/bootstrap.ts
+var SKIP_GUIDANCE_AGENTS = new Set(["agentlife"]);
+var SKIP_AGENTS_MD_INJECTION = new Set(["agentlife", "agentlife-builder", "quick"]);
+function registerBootstrapHook(api, state) {
+  api.registerService({
+    id: "agentlife-bootstrap-hook",
+    start: () => {
+      registerBootstrapHookImpl(api, state);
+    }
+  });
+}
+function registerBootstrapHookImpl(api, state) {
+  api.registerHook("agent:bootstrap", (event) => {
+    if (state.disabled)
+      return;
+    const ctx = event.context;
+    if (!ctx?.bootstrapFiles) {
+      return;
+    }
+    if (isChannelSession(ctx.sessionKey)) {
+      console.log("[agentlife:bootstrap] SKIP channel session %s — no injection", ctx.sessionKey);
+      return;
+    }
+    console.log("[agentlife:bootstrap] agentId=%s sessionKey=%s files=%s", ctx.agentId ?? "NONE", ctx.sessionKey ?? "NONE", ctx.bootstrapFiles.map((f) => `${f.name}(${f.content?.length ?? 0})`).join(", "));
+    if (ctx.agentId && SKIP_GUIDANCE_AGENTS.has(ctx.agentId)) {
+      const registryContext = buildAgentRegistryContext(state);
+      if (registryContext) {
+        const regIdx = ctx.bootstrapFiles.findIndex((f) => f.name === "AGENT_REGISTRY.md");
+        const regEntry = {
+          name: "AGENT_REGISTRY.md",
+          path: "agentlife://agent-registry",
+          content: registryContext,
+          missing: false
+        };
+        if (regIdx >= 0) {
+          ctx.bootstrapFiles[regIdx] = regEntry;
+        } else {
+          ctx.bootstrapFiles.push(regEntry);
+        }
+        console.log("[agentlife] injected agent registry (%d agents) into %s bootstrap", state.agentRegistry.size, ctx.agentId);
+      } else {
+        console.log("[agentlife] no agents in registry for %s bootstrap", ctx.agentId);
+      }
+      if (ctx.sessionKey) {
+        const snap = ctx.bootstrapFiles.map((f) => ({ ...f }));
+        state.sessionBootstrapSnapshots.set(ctx.sessionKey, snap);
+        persistBootstrapSnapshot(state, ctx.sessionKey, ctx.agentId, snap);
+      }
+      return;
+    }
+    const agentsIdx = ctx.bootstrapFiles.findIndex((f) => f.name === "AGENTS.md");
+    const skipAgentsMd = ctx.agentId && SKIP_AGENTS_MD_INJECTION.has(ctx.agentId);
+    if (agentsIdx >= 0 && !skipAgentsMd && ctx.bootstrapFiles[agentsIdx].path !== "agentlife://agents") {
+      const existing = !ctx.bootstrapFiles[agentsIdx].missing && ctx.bootstrapFiles[agentsIdx].content || "";
+      const isGenericTemplate = /heartbeat|group.?chat|discord|whatsapp|emoji.?react/i.test(existing);
+      const isDelegationTemplate = /sessions_spawn|orchestration\s+space|always\s+delegate/i.test(existing);
+      let roleContent = existing;
+      if ((isGenericTemplate || isDelegationTemplate) && existing.length > 200) {
+        const genericHeaders = /^##\s*(First Run|Every Session|Memory|Safety|External|Group Chat|Tools|Make It Yours|Heartbeat)/mi;
+        const genericStart = existing.search(genericHeaders);
+        roleContent = genericStart > 0 ? existing.slice(0, genericStart).trim() : "";
+        roleContent = roleContent.replace(/^#\s*AGENTS\.md.*$/m, "").trim();
+        console.log("[agentlife] stripped generic template from AGENTS.md for %s (%d → %d chars)", ctx.agentId ?? "unknown", existing.length, roleContent.length);
+      }
+      ctx.bootstrapFiles[agentsIdx] = {
+        name: "AGENTS.md",
+        path: "agentlife://agents",
+        content: (roleContent ? roleContent + `
+
+` : "") + PLATFORM_AGENTS_MD,
+        missing: false
+      };
+    }
+    const STRIP_TEMPLATES = ["IDENTITY.md", "USER.md", "HEARTBEAT.md", "BOOTSTRAP.md"];
+    for (const fileName of STRIP_TEMPLATES) {
+      const fi = ctx.bootstrapFiles.findIndex((f) => f.name === fileName);
+      if (fi >= 0 && !ctx.bootstrapFiles[fi].missing) {
+        ctx.bootstrapFiles[fi] = { name: fileName, path: ctx.bootstrapFiles[fi].path, content: "", missing: true };
+      }
+    }
+    const SOUL_MARKER = "# Agent Life Voice";
+    const soulIdx = ctx.bootstrapFiles.findIndex((f) => f.name === "SOUL.md");
+    if (soulIdx >= 0 && ctx.bootstrapFiles[soulIdx].path !== "agentlife://soul") {
+      const userSoulMd = !ctx.bootstrapFiles[soulIdx].missing && ctx.bootstrapFiles[soulIdx].content || "";
+      const wrapped = buildPlatformSoulMd(userSoulMd);
+      ctx.bootstrapFiles[soulIdx] = {
+        name: "SOUL.md",
+        path: "agentlife://soul",
+        content: wrapped,
+        missing: false
+      };
+      const agentLabel = ctx.agentId ?? "unknown";
+      console.log("[agentlife:diff] %s", JSON.stringify({
+        file: "SOUL.md",
+        agent: agentLabel,
+        before: userSoulMd.slice(0, 3000),
+        after: wrapped.slice(0, 3000),
+        beforeLen: userSoulMd.length,
+        afterLen: wrapped.length
+      }));
+    }
+    const idx = ctx.bootstrapFiles.findIndex((f) => f.name === "TOOLS.md");
+    const toolsAlreadyInjected = idx >= 0 && ctx.bootstrapFiles[idx].path === "agentlife://a2ui-guidance";
+    if (!toolsAlreadyInjected) {
+      const originalTools = idx >= 0 && !ctx.bootstrapFiles[idx].missing && ctx.bootstrapFiles[idx].content || "";
+      const entry = {
+        name: "TOOLS.md",
+        path: "agentlife://a2ui-guidance",
+        content: TENAZITAS_GUIDANCE,
+        missing: false
+      };
+      if (idx >= 0) {
+        ctx.bootstrapFiles[idx] = entry;
+      } else {
+        ctx.bootstrapFiles.push(entry);
+      }
+      const agentLabel = ctx.agentId ?? "unknown";
+      console.log("[agentlife:diff] %s", JSON.stringify({
+        file: "TOOLS.md",
+        agent: agentLabel,
+        before: originalTools.slice(0, 3000),
+        after: TENAZITAS_GUIDANCE.slice(0, 3000),
+        beforeLen: originalTools.length,
+        afterLen: TENAZITAS_GUIDANCE.length
+      }));
+    }
+    if (ctx.sessionKey) {
+      const snap = ctx.bootstrapFiles.map((f) => ({ ...f }));
+      state.sessionBootstrapSnapshots.set(ctx.sessionKey, snap);
+      persistBootstrapSnapshot(state, ctx.sessionKey, ctx.agentId, snap);
+    }
+  }, { name: "agentlife-a2ui-guidance", description: "Inject A2UI component catalog and dashboard rules" });
+}
+
+// usage.ts
+var MODEL_COSTS = {
+  "claude-opus": { input: 15, output: 75, cacheRead: 1.5, cacheWrite: 18.75 },
+  "claude-sonnet": { input: 3, output: 15, cacheRead: 0.3, cacheWrite: 3.75 },
+  "claude-haiku": { input: 0.8, output: 4, cacheRead: 0.08, cacheWrite: 1 },
+  "gpt-4o": { input: 2.5, output: 10, cacheRead: 1.25, cacheWrite: 2.5 },
+  "gpt-4.1": { input: 2, output: 8, cacheRead: 0.5, cacheWrite: 2 },
+  o3: { input: 2, output: 8, cacheRead: 0.5, cacheWrite: 2 },
+  "o4-mini": { input: 1.1, output: 4.4, cacheRead: 0.275, cacheWrite: 1.1 },
+  "gemini-2.5-pro": { input: 1.25, output: 10, cacheRead: 0.315, cacheWrite: 1.25 },
+  "gemini-2.5-flash": { input: 0.15, output: 0.6, cacheRead: 0.0375, cacheWrite: 0.15 }
+};
+function estimateCost(model, usage) {
+  if (!model)
+    return 0;
+  const m = model.toLowerCase();
+  let costs;
+  for (const [prefix, c] of Object.entries(MODEL_COSTS)) {
+    if (m.includes(prefix)) {
+      costs = c;
+      break;
+    }
+  }
+  if (!costs)
+    return 0;
+  return ((usage.input ?? 0) * costs.input + (usage.output ?? 0) * costs.output + (usage.cacheRead ?? 0) * costs.cacheRead + (usage.cacheWrite ?? 0) * costs.cacheWrite) / 1e6;
+}
+function recordUsageLedger(state, sessionKey, agentId, provider, model, usage) {
+  if (!usage)
+    return;
+  const input = usage.input ?? 0;
+  const output = usage.output ?? 0;
+  const cacheRead = usage.cacheRead ?? 0;
+  const cacheWrite = usage.cacheWrite ?? 0;
+  const total = usage.total ?? input + output + cacheRead + cacheWrite;
+  if (total === 0)
+    return;
+  const cost = estimateCost(model, usage);
+  try {
+    getOrCreateHistoryDb(state).prepare(`INSERT INTO usage_ledger (sessionKey,agentId,provider,model,inputTokens,outputTokens,cacheReadTokens,cacheWriteTokens,totalTokens,estimatedCost,createdAt)
+         VALUES (?,?,?,?,?,?,?,?,?,?,?)`).run(sessionKey, agentId, provider ?? null, model ?? null, input, output, cacheRead, cacheWrite, total, cost, Date.now());
+  } catch (err) {
+    console.warn("[agentlife] failed to record usage:", err?.message);
+  }
+}
+function accumulateUsage(state, sessionKey, agentId, model, usage) {
+  if (!usage)
+    return;
+  const input = usage.input ?? 0;
+  const output = usage.output ?? 0;
+  const cacheRead = usage.cacheRead ?? 0;
+  const cacheWrite = usage.cacheWrite ?? 0;
+  const total = usage.total ?? input + output + cacheRead + cacheWrite;
+  if (total === 0)
+    return;
+  const pending = state.usageAccumulator.get(sessionKey) ?? {
+    inputTokens: 0,
+    outputTokens: 0,
+    cacheReadTokens: 0,
+    cacheWriteTokens: 0,
+    totalTokens: 0,
+    estimatedCost: 0,
+    llmCalls: 0,
+    agentId: null
+  };
+  pending.inputTokens += input;
+  pending.outputTokens += output;
+  pending.cacheReadTokens += cacheRead;
+  pending.cacheWriteTokens += cacheWrite;
+  pending.totalTokens += total;
+  pending.estimatedCost += estimateCost(model, usage);
+  pending.llmCalls += 1;
+  pending.agentId = agentId ?? pending.agentId;
+  state.usageAccumulator.set(sessionKey, pending);
+}
+function drainAccumulatorToSurfaces(state, sessionKey, surfaceIds) {
+  const pending = state.usageAccumulator.get(sessionKey);
+  if (!pending || pending.llmCalls === 0 || surfaceIds.length === 0)
+    return;
+  const share = surfaceIds.length;
+  const now = Date.now();
+  try {
+    const db = getOrCreateHistoryDb(state);
+    const stmt = db.prepare(`INSERT INTO surface_usage (surfaceId,agentId,sessionKey,inputTokens,outputTokens,cacheReadTokens,cacheWriteTokens,totalTokens,estimatedCost,llmCalls,createdAt)
+       VALUES (?,?,?,?,?,?,?,?,?,?,?)`);
+    for (const sid of surfaceIds) {
+      stmt.run(sid, pending.agentId, sessionKey, Math.round(pending.inputTokens / share), Math.round(pending.outputTokens / share), Math.round(pending.cacheReadTokens / share), Math.round(pending.cacheWriteTokens / share), Math.round(pending.totalTokens / share), pending.estimatedCost / share, pending.llmCalls, now);
+    }
+  } catch (err) {
+    console.warn("[agentlife] failed to record surface usage:", err?.message);
+  }
+  state.usageAccumulator.delete(sessionKey);
+}
+
+// distribution.ts
+var broadcastRef = null;
+function captureBridge(context) {
+  if (!broadcastRef && context?.broadcast) {
+    broadcastRef = context.broadcast;
+    console.log("[agentlife:distribution] broadcast bridge captured");
+  }
+}
+function broadcastSurface(dsl) {
+  if (!broadcastRef)
+    return;
+  broadcastRef("agentlife.surface.push", { dsl, timestamp: Date.now() });
+}
+function broadcastDelete(surfaceId) {
+  if (!broadcastRef)
+    return;
+  broadcastRef("agentlife.surface.delete", { surfaceId, timestamp: Date.now() });
+}
+function broadcastInput(message, sessionKey) {
+  if (!broadcastRef)
+    return;
+  broadcastRef("agentlife.input", { message, sessionKey, timestamp: Date.now() });
+}
+function broadcastActivity(event, sessionKey, agentId, payload) {
+  if (!broadcastRef)
+    return;
+  broadcastRef("agentlife.activity", { event, sessionKey, agentId, ...payload, timestamp: Date.now() });
+}
+
+// notifications.ts
+import * as fs4 from "node:fs";
+import * as path7 from "node:path";
+var config;
+var recentNotifications = new Map;
+var DEBOUNCE_MS = 60000;
+function loadConfig() {
+  if (config !== undefined)
+    return config;
+  try {
+    const configPath = path7.join(process.env.HOME ?? "~", ".openclaw", "agentlife", "notification-config.json");
+    const raw = fs4.readFileSync(configPath, "utf-8");
+    const parsed = JSON.parse(raw);
+    if (parsed.serverUrl && parsed.apiKey) {
+      config = { serverUrl: parsed.serverUrl, apiKey: parsed.apiKey };
+      console.log("[agentlife:notify] Notification config loaded from %s", configPath);
+      return config;
+    }
+    console.warn("[agentlife:notify] Config missing serverUrl or apiKey");
+    config = null;
+    return null;
+  } catch (e) {
+    if (e?.code !== "ENOENT") {
+      console.warn("[agentlife:notify] Failed to load notification config: %s", e?.message);
+    }
+    config = null;
+    return null;
+  }
+}
+function notifyWidgetEvent(_state, event, surfaceId, title, body) {
+  const cfg = loadConfig();
+  if (!cfg)
+    return;
+  const now = Date.now();
+  const lastNotified = recentNotifications.get(surfaceId);
+  if (lastNotified && now - lastNotified < DEBOUNCE_MS)
+    return;
+  recentNotifications.set(surfaceId, now);
+  if (recentNotifications.size > 100) {
+    for (const [sid, ts] of recentNotifications) {
+      if (now - ts > DEBOUNCE_MS)
+        recentNotifications.delete(sid);
+    }
+  }
+  const url = `${cfg.serverUrl.replace(/\/+$/, "")}/api/v1/notifications/send`;
+  fetch(url, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${cfg.apiKey}`
+    },
+    body: JSON.stringify({ title, body, data: { event, surfaceId } }),
+    signal: AbortSignal.timeout(1e4)
+  }).then((res) => {
+    if (!res.ok) {
+      console.warn("[agentlife:notify] Server responded %d for %s", res.status, surfaceId);
+    }
+  }).catch((err) => {
+    console.warn("[agentlife:notify] Server failed for %s: %s", surfaceId, err?.message);
+  });
+}
+
+// tools/widget-push.ts
+function registerWidgetPushTool(api, state) {
+  api.registerTool((ctx) => {
+    const sessionKey = ctx?.sessionKey ?? null;
+    const agentId = ctx?.agentId ?? null;
+    return {
+      name: "agentlife_push",
+      label: "Widget Push",
+      description: "Push or update widgets on the AgentLife dashboard using Widget DSL. " + "Each DSL block defines a surface (widget) with content, goal, followup schedule, and context. " + "Separate multiple blocks with ---.",
+      parameters: {
+        type: "object",
+        properties: {
+          dsl: {
+            type: "string",
+            description: "Widget DSL — one or more surface blocks separated by ---"
+          }
+        },
+        required: ["dsl"]
+      },
+      async execute(_toolCallId, params) {
+        const dsl = params.dsl;
+        if (!dsl || typeof dsl !== "string") {
+          return { content: [{ type: "text", text: "Error: dsl parameter required" }] };
+        }
+        if (!agentId) {
+          console.log("[agentlife] agentlife_push tool has no agentId from context");
+        }
+        const blocks = dsl.split(/\n---(?:\n|$)/).filter((b) => b.trim().length > 0);
+        const pushSurfaceIds = [];
+        const newSurfaceIds = [];
+        for (const block of blocks) {
+          const match = block.match(/^surface\s+(\S+)/m);
+          if (match) {
+            pushSurfaceIds.push(match[1]);
+            if (!state.surfaceDb?.has(match[1]))
+              newSurfaceIds.push(match[1]);
+          }
+        }
+        const dslResults = processDslBlock(state, dsl);
+        if (agentId && state.surfaceDb) {
+          for (const sid of pushSurfaceIds) {
+            state.surfaceDb.setAgentId(sid, agentId);
+          }
+        }
+        broadcastSurface(dsl);
+        for (const block of blocks) {
+          if (block.trim().startsWith("delete ")) {
+            const deleteMatch = block.trim().match(/^delete\s+(\S+)/);
+            if (deleteMatch)
+              broadcastDelete(deleteMatch[1]);
+          }
+        }
+        for (const sid of newSurfaceIds) {
+          const meta = state.surfaceDb?.get(sid);
+          if (!meta)
+            continue;
+          const headerLine = meta.lines[0] ?? "";
+          if (/\boverlay\b/.test(headerLine) || /\binput\b/.test(headerLine) || /\bstate=loading\b/.test(headerLine))
+            continue;
+          const notifTitle = capitalize(agentId ?? "agent");
+          const notifBody = extractWidgetText(meta) ?? "New update";
+          notifyWidgetEvent(state, "surface_created", sid, notifTitle, notifBody);
+        }
+        for (const result of dslResults) {
+          const meta = state.surfaceDb?.get(result.surfaceId);
+          if (!meta)
+            continue;
+          if (result.stateTransition?.endsWith("->terminal")) {
+            removeFollowup(state, result.surfaceId);
+            continue;
+          }
+          if (result.followupRemoved) {
+            removeFollowup(state, result.surfaceId);
+          } else if (meta.followup && (result.followupChanged || result.isNew)) {
+            scheduleFollowup(state, result.surfaceId, meta.followup, agentId);
+          }
+          if (meta.context) {
+            autoRegisterInfraFromContext(state, result.surfaceId, agentId, meta.context);
+          }
+        }
+        if (sessionKey && pushSurfaceIds.length > 0) {
+          drainAccumulatorToSurfaces(state, sessionKey, pushSurfaceIds);
+        }
+        const summary = pushSurfaceIds.length === 1 ? `Widget ${pushSurfaceIds[0]} updated` : `${pushSurfaceIds.length} widgets updated`;
+        return { content: [{ type: "text", text: summary }] };
+      }
+    };
+  });
+}
+function capitalize(s) {
+  return s.charAt(0).toUpperCase() + s.slice(1);
+}
+function extractWidgetText(meta) {
+  const headingLine = meta.lines.find((l) => /^\s*text\s+"[^"]+"\s+h[1-4]/.test(l));
+  if (headingLine)
+    return headingLine.match(/text\s+"([^"]+)"/)?.[1] ?? null;
+  const goalLine = meta.lines.find((l) => /^\s*goal\s+"[^"]+"/.test(l));
+  if (goalLine)
+    return goalLine.match(/goal\s+"([^"]+)"/)?.[1] ?? null;
+  const textLine = meta.lines.find((l) => /^\s*text\s+"[^"]+"/.test(l));
+  if (textLine)
+    return textLine.match(/text\s+"([^"]+)"/)?.[1] ?? null;
+  return null;
+}
+
+// hooks/activity-hooks.ts
+var sessionContext = new Map;
+function registerActivityHooks(api, state) {
+  api.on("llm_output", (event, ctx) => {
+    if (state.disabled)
+      return;
+    const sessionKey = ctx?.sessionKey ?? event.sessionId ?? "unknown";
+    if (isChannelSession(sessionKey))
+      return;
+    const agentId = ctx?.agentId ?? null;
+    recordUsageLedger(state, sessionKey, agentId, event.provider, event.model, event.usage);
+    accumulateUsage(state, sessionKey, agentId, event.model, event.usage);
+  });
+  api.on("agent_end", (_event, ctx) => {
+    if (state.disabled)
+      return;
+    const sessionKey = ctx?.sessionKey ?? null;
+    if (sessionKey) {
+      state.usageAccumulator.delete(sessionKey);
+      state.sessionBootstrapSnapshots.delete(sessionKey);
+    }
+  });
+  api.on("session_start", (event, ctx) => {
+    if (state.disabled)
+      return;
+    const sessionKey = event.sessionKey ?? ctx?.sessionKey ?? null;
+    if (isChannelSession(sessionKey))
+      return;
+    const agentId = ctx?.agentId ?? null;
+    recordActivity(state, "session_start", sessionKey, agentId, {
+      runId: ctx?.runId ?? null,
+      data: JSON.stringify({ sessionId: event.sessionId, resumedFrom: event.resumedFrom })
+    });
+    const message = event.message ?? ctx?.message ?? "";
+    if (sessionKey && message) {
+      sessionContext.set(sessionKey, { message, startedAt: Date.now() });
+    }
+    const cronMatch = message.match(/^Widget followup for (\S+):/);
+    if (cronMatch) {
+      const cronSurfaceId = cronMatch[1];
+      recordSurfaceEvent(state, cronSurfaceId, "cron_fired", undefined, agentId ?? undefined);
+      const meta = state.surfaceDb?.get(cronSurfaceId);
+      const agentLabel = agentId ? agentId.charAt(0).toUpperCase() + agentId.slice(1) : "Agent";
+      const surfaceTitle = extractCronTitle(meta) ?? "Updated";
+      notifyWidgetEvent(state, "cron_followup", cronSurfaceId, agentLabel, surfaceTitle);
+      if (agentId && state.runCommand) {
+        state.runCommand(["openclaw", "agent", "--agent", agentId, "--message", message, "--json"], { timeoutMs: 120000 }).catch((e) => console.warn("[agentlife] followup redirect failed for %s: %s", cronSurfaceId, e?.message));
+        console.log("[agentlife] followup redirected to agent:%s:main for %s", agentId, cronSurfaceId);
+      }
+    }
+  });
+  api.on("llm_output", (event, ctx) => {
+    if (state.disabled)
+      return;
+    const sessionKey = ctx?.sessionKey ?? event.sessionId ?? "unknown";
+    if (isChannelSession(sessionKey))
+      return;
+    const agentId = ctx?.agentId ?? null;
+    const texts = event.assistantTexts ?? [];
+    const lastAssistant = event.lastAssistant;
+    let thinking = null;
+    if (lastAssistant && typeof lastAssistant === "object") {
+      const content = Array.isArray(lastAssistant.content) ? lastAssistant.content : [];
+      const thinkingBlocks = content.filter((b) => b.type === "thinking" && b.thinking).map((b) => b.thinking);
+      if (thinkingBlocks.length > 0)
+        thinking = thinkingBlocks.join(`
+`);
+    }
+    if (texts.length > 0 || thinking) {
+      recordActivity(state, "llm_response", sessionKey, agentId, {
+        runId: event.runId ?? ctx?.runId ?? null,
+        summary: texts.join(`
+`).slice(0, 500) || null,
+        data: JSON.stringify({
+          texts,
+          thinking,
+          model: event.model,
+          provider: event.provider,
+          usage: event.usage
+        })
+      });
+    }
+  }, { priority: 100 });
+  api.on("before_tool_call", (event, ctx) => {
+    if (state.disabled)
+      return;
+    const sessionKey = ctx?.sessionKey ?? null;
+    if (isChannelSession(sessionKey))
+      return;
+    const agentId = ctx?.agentId ?? null;
+    const toolName = event.toolName ?? ctx?.toolName;
+    const toolCallId = event.toolCallId ?? ctx?.toolCallId ?? null;
+    const runId = event.runId ?? ctx?.runId ?? null;
+    recordActivity(state, "tool_start", sessionKey, agentId, {
+      toolName,
+      runId,
+      summary: summarizeParams(event.params),
+      data: JSON.stringify({ params: event.params, toolCallId })
+    });
+    const broadcastExtra = {};
+    if (toolName === "sessions_send" && typeof event.params?.sessionKey === "string") {
+      const match = event.params.sessionKey.match(/^agent:([^:]+):/);
+      if (match)
+        broadcastExtra.targetAgentId = match[1];
+    }
+    broadcastActivity("tool_start", sessionKey, agentId, {
+      toolName,
+      toolCallId,
+      runId,
+      inputSummary: summarizeParams(event.params),
+      ...broadcastExtra
+    });
+  });
+  api.on("after_tool_call", (event, ctx) => {
+    if (state.disabled)
+      return;
+    const sessionKey = ctx?.sessionKey ?? null;
+    if (isChannelSession(sessionKey))
+      return;
+    const agentId = ctx?.agentId ?? null;
+    const isError = !!event.error;
+    const toolName = event.toolName ?? ctx?.toolName;
+    const toolCallId = event.toolCallId ?? ctx?.toolCallId ?? null;
+    const runId = event.runId ?? ctx?.runId ?? null;
+    let canvasDsl = null;
+    if (event.toolName === "agentlife_push" && typeof event.params?.dsl === "string") {
+      canvasDsl = event.params.dsl;
+    }
+    const resultStr = typeof event.result === "string" ? event.result : event.result != null ? JSON.stringify(event.result) : null;
+    recordActivity(state, "tool_end", sessionKey, agentId, {
+      toolName,
+      runId,
+      summary: isError ? event.error : resultStr?.slice(0, 300) ?? null,
+      data: JSON.stringify({
+        params: event.params,
+        result: resultStr?.slice(0, 1e4),
+        error: event.error,
+        isError,
+        durationMs: event.durationMs,
+        toolCallId,
+        canvasDsl
+      })
+    });
+    broadcastActivity("tool_end", sessionKey, agentId, {
+      toolName,
+      toolCallId,
+      runId,
+      isError,
+      resultSummary: isError ? event.error : resultStr?.slice(0, 300) ?? null
+    });
+    if (event.toolName === "write" || event.toolName === "exec") {
+      const filePath = event.params?.path ?? event.params?.command ?? "";
+      if (typeof filePath === "string" && filePath.includes("workspace-") && filePath.includes("AGENTS.md")) {
+        const content = event.params?.content ?? "";
+        const issues = [];
+        if (typeof content === "string" && content.length > 0) {
+          if (!/followup/i.test(content))
+            issues.push("no followup strategy");
+          if (!/goal/i.test(content))
+            issues.push("no goal patterns");
+          if (!/approv/i.test(content))
+            issues.push("no approval patterns");
+          if (issues.length > 0) {
+            console.warn("[agentlife:builder] AGENTS.md write missing: %s", issues.join(", "));
+            recordActivity(state, "builder_validation", sessionKey, agentId, {
+              summary: `AGENTS.md missing: ${issues.join(", ")}`,
+              data: JSON.stringify({ file: filePath, issues })
+            });
+          }
+        }
+      }
+    }
+  }, { priority: 100 });
+  api.on("agent_end", (event, ctx) => {
+    if (state.disabled)
+      return;
+    const sessionKey = ctx?.sessionKey ?? null;
+    const agentId = ctx?.agentId ?? null;
+    recordActivity(state, "agent_end", sessionKey, agentId, {
+      runId: ctx?.runId ?? null,
+      data: JSON.stringify({
+        success: event.success,
+        error: event.error,
+        durationMs: event.durationMs
+      })
+    });
+    if (agentId && state.surfaceDb) {
+      for (const [sid, meta] of state.surfaceDb.entries()) {
+        if (state.surfaceDb.getAgentId(sid) !== agentId)
+          continue;
+        const headerLine = meta.lines[0] ?? "";
+        if (!/\bstate=loading\b/.test(headerLine))
+          continue;
+        meta.lines[0] = headerLine.replace(/\bstate=loading\b/, "state=error");
+        state.surfaceDb.set(sid, { ...meta, updatedAt: Date.now() });
+        recordSurfaceEvent(state, sid, "loading_resolved_error", undefined, agentId, JSON.stringify({ reason: event.error ?? "agent ended with orphaned loading", success: event.success, runId: ctx?.runId }));
+        console.log("[agentlife] resolved orphaned loading surface %s → error (agent %s, success=%s)", sid, agentId, event.success);
+      }
+    }
+    if (agentId && sessionKey && state.surfaceDb) {
+      persistSessionTrace(state, sessionKey, agentId, event.durationMs);
+    }
+    if (sessionKey)
+      sessionContext.delete(sessionKey);
+  }, { priority: 100 });
+  api.on("message_received", (event, ctx) => {
+    if (state.disabled)
+      return;
+    recordActivity(state, "message_received", null, null, {
+      summary: (event.content ?? "").slice(0, 500),
+      data: JSON.stringify({
+        from: event.from,
+        channelId: ctx?.channelId,
+        accountId: ctx?.accountId,
+        timestamp: event.timestamp
+      })
+    });
+  });
+  api.on("subagent_spawned", (event, ctx) => {
+    if (state.disabled)
+      return;
+    const sessionKey = ctx?.requesterSessionKey ?? null;
+    recordActivity(state, "subagent_spawned", sessionKey, null, {
+      runId: event.runId ?? ctx?.runId ?? null,
+      summary: event.agentId,
+      data: JSON.stringify({
+        childSessionKey: event.childSessionKey,
+        agentId: event.agentId,
+        label: event.label,
+        mode: event.mode
+      })
+    });
+  });
+  api.on("subagent_ended", (event, ctx) => {
+    if (state.disabled)
+      return;
+    const sessionKey = event.targetSessionKey ?? ctx?.childSessionKey ?? null;
+    recordActivity(state, "subagent_ended", sessionKey, null, {
+      runId: event.runId ?? ctx?.runId ?? null,
+      summary: event.outcome ?? event.reason,
+      data: JSON.stringify({
+        targetSessionKey: event.targetSessionKey,
+        reason: event.reason,
+        outcome: event.outcome,
+        error: event.error
+      })
+    });
+  });
+}
+function extractCronTitle(meta) {
+  if (!meta)
+    return null;
+  const headingLine = meta.lines.find((l) => /^\s*text\s+"[^"]+"\s+h[1-4]/.test(l));
+  if (headingLine)
+    return headingLine.match(/text\s+"([^"]+)"/)?.[1] ?? null;
+  const goalLine = meta.lines.find((l) => /^\s*goal\s+"[^"]+"/.test(l));
+  if (goalLine)
+    return goalLine.match(/goal\s+"([^"]+)"/)?.[1] ?? null;
+  const textLine = meta.lines.find((l) => /^\s*text\s+"[^"]+"/.test(l));
+  if (textLine)
+    return textLine.match(/text\s+"([^"]+)"/)?.[1] ?? null;
+  return null;
+}
+function persistSessionTrace(state, sessionKey, agentId, durationMs) {
+  try {
+    const now = Date.now();
+    const sessionStart = sessionContext.get(sessionKey)?.startedAt ?? (durationMs ? now - durationMs - 5000 : now - 120000);
+    const touchedSurfaces = [];
+    for (const [sid, meta] of state.surfaceDb.entries()) {
+      if (state.surfaceDb.getAgentId(sid) !== agentId)
+        continue;
+      if (meta.updatedAt >= sessionStart) {
+        touchedSurfaces.push(sid);
+      }
+    }
+    if (touchedSurfaces.length === 0)
+      return;
+    const db = getOrCreateHistoryDb(state);
+    const entries = db.prepare(`SELECT ts, sessionKey, agentId, event, toolName, summary, data, runId
+       FROM activity_log
+       WHERE sessionKey = ? AND ts >= ?
+       ORDER BY ts ASC
+       LIMIT 500`).all(sessionKey, sessionStart);
+    if (entries.length === 0)
+      return;
+    const rawMessage = sessionContext.get(sessionKey)?.message ?? "";
+    const cronLabelMatch = rawMessage.match(/\]\s*Widget followup for \S+.*?:\s*(.*)/s);
+    const queryText = cronLabelMatch?.[1]?.trim() || rawMessage.replace(/^\[(?:system|action)[^\]]*\]\s*/i, "").trim();
+    for (const surfaceId of touchedSurfaces) {
+      const traceMetadata = JSON.stringify({
+        query: queryText,
+        agent: agentId,
+        sessionKey,
+        entries: entries.map((e) => ({
+          ts: e.ts,
+          event: e.event,
+          toolName: e.toolName ?? undefined,
+          summary: e.summary ?? undefined,
+          data: e.data ?? undefined,
+          runId: e.runId ?? undefined
+        }))
+      });
+      recordSurfaceEvent(state, surfaceId, "trace", undefined, agentId, traceMetadata);
+    }
+    console.log("[agentlife] persisted trace for %d surfaces (agent=%s, entries=%d)", touchedSurfaces.length, agentId, entries.length);
+  } catch (err) {
+    console.warn("[agentlife] failed to persist session trace:", err?.message);
+  }
+}
+
+// hooks/prompt-state.ts
+function registerPromptStateHook(api, state) {
+  api.on("before_prompt_build", (_event, ctx) => {
+    if (state.disabled)
+      return;
+    if (isChannelSession(ctx?.sessionKey))
+      return;
+    const agentId = ctx?.agentId;
+    const isOrchestrator = agentId === "agentlife";
+    const dashboardState = buildDashboardStateContext(state, agentId);
+    if (!dashboardState) {
+      console.log("[agentlife:prompt-state] agentId=%s — no dashboard state (surfaceDb size=%d)", agentId ?? "NONE", state.surfaceDb?.size ?? 0);
+      return;
+    }
+    let registryContext = "";
+    if (isOrchestrator) {
+      registryContext = buildAgentRegistryContext(state) ?? "";
+    }
+    const parts = [];
+    if (dashboardState)
+      parts.push(dashboardState);
+    if (registryContext)
+      parts.push(registryContext);
+    if (parts.length === 0)
+      return;
+    const joined = parts.join(`
+
+`);
+    console.log(`[agentlife:prompt-state] agentId=%s injecting %d chars (dashboard=%d, registry=%d)
+%s`, agentId ?? "NONE", joined.length, dashboardState?.length ?? 0, registryContext.length, joined);
+    return {
+      appendSystemContext: joined
+    };
+  });
+}
+
+// gateway/agents.ts
+import * as fs5 from "node:fs";
+import * as path8 from "node:path";
+function registerAgentGateway(api, state) {
+  api.registerGatewayMethod("agentlife.createAgent", async ({ params, respond }) => {
+    const id = typeof params?.id === "string" ? params.id.trim() : "";
+    const name = typeof params?.name === "string" ? params.name.trim() : "";
+    const model = typeof params?.model === "string" ? params.model.trim() : "";
+    const workspace = typeof params?.workspace === "string" ? params.workspace.trim() : "";
+    const description = typeof params?.description === "string" ? params.description.trim() : "";
+    const tools = params?.tools && typeof params.tools === "object" ? params.tools : undefined;
+    const subagents = params?.subagents && typeof params.subagents === "object" ? params.subagents : undefined;
+    const identity = params?.identity && typeof params.identity === "object" ? params.identity : undefined;
+    if (!id) {
+      respond(false, { error: "missing agent id" });
+      return;
+    }
+    if (!workspace) {
+      respond(false, { error: "missing workspace path" });
+      return;
+    }
+    const cfg = api.runtime.config.loadConfig();
+    const currentList = cfg.agents?.list ?? [];
+    const existing = currentList.find((a) => a.id === id);
+    if (!existing) {
+      const entry = { id, workspace };
+      if (name)
+        entry.name = name;
+      if (model)
+        entry.model = model;
+      if (tools)
+        entry.tools = tools;
+      if (subagents)
+        entry.subagents = subagents;
+      if (identity)
+        entry.identity = identity;
+      const updatedCfg = {
+        ...cfg,
+        agents: {
+          ...cfg.agents,
+          list: [...currentList, entry]
+        }
+      };
+      await api.runtime.config.writeConfigFile(updatedCfg);
+      console.log("[agentlife] builder created agent: %s (workspace: %s)", id, workspace);
+    } else {
+      let patched = false;
+      if (tools && !existing.tools) {
+        existing.tools = tools;
+        patched = true;
+      }
+      if (subagents && !existing.subagents) {
+        existing.subagents = subagents;
+        patched = true;
+      }
+      if (identity && !existing.identity) {
+        existing.identity = identity;
+        patched = true;
+      }
+      if (model && !existing.model) {
+        existing.model = model;
+        patched = true;
+      }
+      if (patched) {
+        const updatedCfg = { ...cfg, agents: { ...cfg.agents, list: currentList } };
+        await api.runtime.config.writeConfigFile(updatedCfg);
+        console.log("[agentlife] builder patched agent config: %s", id);
+      }
+    }
+    if (description && isUsableDescription(description, id, name)) {
+      state.agentRegistry.set(id, {
+        name: name || id,
+        description,
+        model: model || undefined,
+        createdAt: state.agentRegistry.get(id)?.createdAt ?? Date.now()
+      });
+      await saveRegistryToDisk(state);
+      console.log("[agentlife] registered agent in registry: %s — %s", id, description);
+    } else if (description) {
+      console.log("[agentlife] rejected low-quality description for %s: %s", id, description);
+    }
+    const status = existing ? "exists" : "created";
+    const configFields = [];
+    if (tools)
+      configFields.push("tools");
+    if (subagents)
+      configFields.push("subagents");
+    if (identity)
+      configFields.push("identity");
+    respond(true, { status, id, name, model, workspace, description, ...configFields.length ? { configFields } : {} });
+  });
+  api.registerGatewayMethod("agentlife.deleteAgent", async ({ params, respond }) => {
+    const id = typeof params?.id === "string" ? params.id.trim() : "";
+    if (!id) {
+      respond(false, { error: "missing agent id" });
+      return;
+    }
+    const provisionedIds = new Set(PROVISIONED_AGENTS.map((a) => a.id));
+    if (provisionedIds.has(id)) {
+      respond(false, { error: "cannot delete provisioned agent" });
+      return;
+    }
+    const cleanup = { sessions: 0, cronJobs: 0, historyRows: 0, agentDbDeleted: false };
+    if (state.runCommand) {
+      try {
+        const sessResult = await state.runCommand(["openclaw", "gateway", "call", "sessions.list"], { timeoutMs: 1e4 });
+        const sessions = sessResult?.result?.sessions ?? sessResult?.sessions ?? [];
+        for (const sess of sessions) {
+          if (sess.agentId === id) {
+            try {
+              await state.runCommand(["openclaw", "gateway", "call", "sessions.delete", JSON.stringify({ key: sess.key, deleteTranscript: true })], { timeoutMs: 1e4 });
+              cleanup.sessions++;
+            } catch {}
+          }
+        }
+      } catch (e) {
+        console.warn("[agentlife] deleteAgent: failed to clean sessions:", e?.message);
+      }
+      try {
+        const cronResult = await state.runCommand(["openclaw", "cron", "list", "--json"], { timeoutMs: 1e4 });
+        const jobs = Array.isArray(cronResult) ? cronResult : cronResult?.jobs ?? [];
+        for (const job of jobs) {
+          if (job.agentId === id) {
+            try {
+              await state.runCommand(["openclaw", "cron", "rm", String(job.id)], { timeoutMs: 1e4 });
+              cleanup.cronJobs++;
+            } catch {}
+          }
+        }
+      } catch (e) {
+        console.warn("[agentlife] deleteAgent: failed to clean cron jobs:", e?.message);
+      }
+    }
+    try {
+      const histDb = getOrCreateHistoryDb(state);
+      const tables = ["surfaces", "surface_events", "surface_usage", "usage_ledger", "activity_log", "automations"];
+      for (const table of tables) {
+        const result = histDb.prepare(`DELETE FROM ${table} WHERE agentId = ?`).run(id);
+        cleanup.historyRows += result.changes;
+      }
+    } catch (e) {
+      console.warn("[agentlife] deleteAgent: failed to clean history DB:", e?.message);
+    }
+    const agentDb = state.agentDbs.get(id);
+    if (agentDb) {
+      try {
+        agentDb.close();
+      } catch {}
+      state.agentDbs.delete(id);
+    }
+    if (state.dbBaseDir) {
+      const dbPath = path8.join(state.dbBaseDir, `${id}.db`);
+      try {
+        if (fs5.existsSync(dbPath)) {
+          fs5.unlinkSync(dbPath);
+          cleanup.agentDbDeleted = true;
+        }
+      } catch (e) {
+        console.warn("[agentlife] deleteAgent: failed to delete agent DB:", e?.message);
+      }
+    }
+    const cfg = api.runtime.config.loadConfig();
+    const currentList = cfg.agents?.list ?? [];
+    const filtered = currentList.filter((a) => a.id !== id);
+    const removedFromConfig = filtered.length < currentList.length;
+    if (removedFromConfig) {
+      const updatedCfg = {
+        ...cfg,
+        agents: {
+          ...cfg.agents,
+          list: filtered
+        }
+      };
+      await api.runtime.config.writeConfigFile(updatedCfg);
+    }
+    const removedFromRegistry = state.agentRegistry.delete(id);
+    if (removedFromRegistry) {
+      await saveRegistryToDisk(state);
+    }
+    console.log("[agentlife] deleted agent: %s (config=%s, registry=%s, sessions=%d, cron=%d, historyRows=%d, agentDb=%s)", id, removedFromConfig, removedFromRegistry, cleanup.sessions, cleanup.cronJobs, cleanup.historyRows, cleanup.agentDbDeleted);
+    respond(true, { status: "deleted", id, removedFromConfig, removedFromRegistry, cleanup });
+  });
+  api.registerGatewayMethod("agentlife.agents", ({ respond }) => {
+    const agents = {};
+    for (const [id, entry] of state.agentRegistry.entries()) {
+      agents[id] = { name: entry.name, description: entry.description, model: entry.model };
+    }
+    respond(true, { agents, count: state.agentRegistry.size });
+  }, { scope: "operator.read" });
+}
+
+// gateway/db-access.ts
+function registerDbGateway(api, state) {
+  api.registerGatewayMethod("agentlife.db.exec", ({ params, respond }) => {
+    const agentId = typeof params?.agentId === "string" ? params.agentId.trim() : "";
+    const sql = typeof params?.sql === "string" ? params.sql.trim() : "";
+    const sqlParams = Array.isArray(params?.params) ? params.params : [];
+    if (!agentId)
+      return respond(false, { error: "missing agentId" });
+    if (!sql)
+      return respond(false, { error: "missing sql" });
+    if (/^\s*SELECT\b/i.test(sql))
+      return respond(false, { error: "use agentlife.db.query for SELECT" });
+    try {
+      const db = getOrCreateAgentDb(state, agentId);
+      if (sqlParams.length > 0) {
+        const result = db.prepare(sql).run(...sqlParams);
+        respond(true, { changes: result.changes ?? 0, lastInsertRowid: Number(result.lastInsertRowid ?? 0) });
+      } else {
+        db.exec(sql);
+        respond(true, { changes: 0, lastInsertRowid: 0 });
+      }
+    } catch (err) {
+      respond(false, { error: err?.message ?? "db error" });
+    }
+  });
+  api.registerGatewayMethod("agentlife.db.query", ({ params, respond }) => {
+    const agentId = typeof params?.agentId === "string" ? params.agentId.trim() : "";
+    const sql = typeof params?.sql === "string" ? params.sql.trim() : "";
+    const sqlParams = Array.isArray(params?.params) ? params.params : [];
+    if (!agentId)
+      return respond(false, { error: "missing agentId" });
+    if (!sql)
+      return respond(false, { error: "missing sql" });
+    if (!/^\s*SELECT\b/i.test(sql))
+      return respond(false, { error: "use agentlife.db.exec for non-SELECT" });
+    try {
+      const db = getOrCreateAgentDb(state, agentId);
+      const rows = db.prepare(sql).all(...sqlParams);
+      const MAX = 1000;
+      const truncated = rows.length > MAX;
+      const result = truncated ? rows.slice(0, MAX) : rows;
+      const columns = result.length > 0 ? Object.keys(result[0]) : [];
+      respond(true, { rows: result, columns, count: result.length, truncated });
+    } catch (err) {
+      respond(false, { error: err?.message ?? "db error" });
+    }
+  });
+}
+
+// gateway/history.ts
+function registerHistoryGateway(api, state) {
+  api.registerGatewayMethod("agentlife.history", ({ params, respond }) => {
+    try {
+      const db = getOrCreateHistoryDb(state);
+      const conds = [];
+      const bind = [];
+      if (typeof params?.surfaceId === "string" && params.surfaceId) {
+        conds.push("surfaceId = ?");
+        bind.push(params.surfaceId);
+      }
+      if (typeof params?.agentId === "string" && params.agentId) {
+        conds.push("agentId = ?");
+        bind.push(params.agentId);
+      }
+      if (typeof params?.event === "string" && params.event) {
+        conds.push("event = ?");
+        bind.push(params.event);
+      }
+      if (typeof params?.search === "string" && params.search) {
+        conds.push("dsl LIKE ?");
+        bind.push(`%${params.search}%`);
+      }
+      if (typeof params?.since === "number") {
+        conds.push("createdAt >= ?");
+        bind.push(params.since);
+      }
+      if (typeof params?.until === "number") {
+        conds.push("createdAt <= ?");
+        bind.push(params.until);
+      }
+      const where = conds.length > 0 ? `WHERE ${conds.join(" AND ")}` : "";
+      const limit = Math.min(typeof params?.limit === "number" ? params.limit : 100, 500);
+      const offset = typeof params?.offset === "number" ? params.offset : 0;
+      bind.push(limit, offset);
+      const rows = db.prepare(`SELECT * FROM surface_events ${where} ORDER BY createdAt DESC LIMIT ? OFFSET ?`).all(...bind);
+      respond(true, { events: rows, count: rows.length });
+    } catch (err) {
+      respond(false, { error: err?.message ?? "history error" });
+    }
+  }, { scope: "operator.read" });
+  api.registerGatewayMethod("agentlife.history.widgets", ({ params, respond }) => {
+    try {
+      const db = getOrCreateHistoryDb(state);
+      const conds = ["dsl IS NOT NULL"];
+      const bind = [];
+      if (typeof params?.search === "string" && params.search) {
+        conds.push("dsl LIKE ?");
+        bind.push(`%${params.search}%`);
+      }
+      if (typeof params?.agentId === "string" && params.agentId) {
+        conds.push("agentId = ?");
+        bind.push(params.agentId);
+      }
+      if (typeof params?.since === "number") {
+        conds.push("createdAt >= ?");
+        bind.push(params.since);
+      }
+      if (typeof params?.until === "number") {
+        conds.push("createdAt <= ?");
+        bind.push(params.until);
+      }
+      const where = conds.join(" AND ");
+      const limit = Math.min(typeof params?.limit === "number" ? params.limit : 50, 200);
+      const offset = typeof params?.offset === "number" ? params.offset : 0;
+      const rows = db.prepare(`
+        SELECT se.surfaceId, se.agentId, se.dsl, se.createdAt
+        FROM surface_events se
+        INNER JOIN (
+          SELECT surfaceId, MAX(id) as maxId
+          FROM surface_events
+          WHERE ${where}
+          GROUP BY surfaceId
+        ) latest ON se.id = latest.maxId
+        ORDER BY se.createdAt DESC
+        LIMIT ? OFFSET ?
+      `).all(...bind, limit, offset);
+      respond(true, { widgets: rows, count: rows.length, hasMore: rows.length >= limit });
+    } catch (err) {
+      respond(false, { error: err?.message ?? "history.widgets error" });
+    }
+  }, { scope: "operator.read" });
+  api.registerGatewayMethod("agentlife.trace", ({ params, respond }) => {
+    try {
+      const db = getOrCreateHistoryDb(state);
+      const conds = [];
+      const args = [];
+      const since = typeof params?.since === "number" ? params.since : null;
+      const until = typeof params?.until === "number" ? params.until : null;
+      if (since != null) {
+        conds.push("ts >= ?");
+        args.push(since);
+      }
+      if (until != null) {
+        conds.push("ts <= ?");
+        args.push(until);
+      }
+      const agentId = typeof params?.agentId === "string" ? params.agentId.trim() : null;
+      if (agentId) {
+        conds.push("agentId = ?");
+        args.push(agentId);
+      }
+      const sessionKey = typeof params?.sessionKey === "string" ? params.sessionKey.trim() : null;
+      if (sessionKey) {
+        conds.push("sessionKey = ?");
+        args.push(sessionKey);
+      }
+      const eventFilter = typeof params?.event === "string" ? params.event.trim() : null;
+      if (eventFilter) {
+        const events = eventFilter.split(",").map((e) => e.trim()).filter(Boolean);
+        if (events.length === 1) {
+          conds.push("event = ?");
+          args.push(events[0]);
+        } else if (events.length > 1) {
+          conds.push(`event IN (${events.map(() => "?").join(",")})`);
+          args.push(...events);
+        }
+      }
+      const limit = Math.min(typeof params?.limit === "number" ? params.limit : 200, 1000);
+      const offset = typeof params?.offset === "number" ? params.offset : 0;
+      const where = conds.length > 0 ? `WHERE ${conds.join(" AND ")}` : "";
+      const rows = db.prepare(`SELECT id,ts,sessionKey,agentId,event,toolName,summary,data,runId FROM activity_log ${where} ORDER BY ts DESC LIMIT ? OFFSET ?`).all(...args, limit + 1, offset);
+      const hasMore = rows.length > limit;
+      const entries = rows.slice(0, limit).map((r) => ({
+        id: r.id,
+        ts: r.ts,
+        sessionKey: r.sessionKey,
+        agentId: r.agentId,
+        event: r.event,
+        toolName: r.toolName,
+        summary: r.summary,
+        data: r.data,
+        runId: r.runId
+      }));
+      respond(true, { entries, hasMore });
+    } catch (err) {
+      respond(false, { error: err?.message ?? "trace query failed" });
+    }
+  }, { scope: "operator.read" });
+}
+
+// gateway/usage-gateway.ts
+function registerUsageGateway(api, state) {
+  api.registerGatewayMethod("agentlife.usage", ({ params, respond }) => {
+    try {
+      const db = getOrCreateHistoryDb(state);
+      const conds = [];
+      const bind = [];
+      if (typeof params?.startDate === "string" && params.startDate) {
+        const startMs = new Date(params.startDate + "T00:00:00").getTime();
+        if (!isNaN(startMs)) {
+          conds.push("createdAt >= ?");
+          bind.push(startMs);
+        }
+      }
+      if (typeof params?.endDate === "string" && params.endDate) {
+        const endMs = new Date(params.endDate + "T23:59:59.999").getTime();
+        if (!isNaN(endMs)) {
+          conds.push("createdAt <= ?");
+          bind.push(endMs);
+        }
+      }
+      if (typeof params?.agentId === "string" && params.agentId) {
+        conds.push("agentId = ?");
+        bind.push(params.agentId);
+      }
+      const where = conds.length > 0 ? `WHERE ${conds.join(" AND ")}` : "";
+      const totalsRow = db.prepare(`SELECT COUNT(*) as llmCalls,
+                COALESCE(SUM(inputTokens),0) as input,
+                COALESCE(SUM(outputTokens),0) as output,
+                COALESCE(SUM(cacheReadTokens),0) as cacheRead,
+                COALESCE(SUM(cacheWriteTokens),0) as cacheWrite,
+                COALESCE(SUM(totalTokens),0) as totalTokens,
+                COALESCE(SUM(estimatedCost),0) as totalCost
+         FROM usage_ledger ${where}`).get(...bind);
+      const dailyRows = db.prepare(`SELECT date(createdAt / 1000, 'unixepoch', 'localtime') as date,
+                COUNT(*) as llmCalls,
+                COALESCE(SUM(inputTokens),0) as input,
+                COALESCE(SUM(outputTokens),0) as output,
+                COALESCE(SUM(cacheReadTokens),0) as cacheRead,
+                COALESCE(SUM(cacheWriteTokens),0) as cacheWrite,
+                COALESCE(SUM(totalTokens),0) as totalTokens,
+                COALESCE(SUM(estimatedCost),0) as totalCost
+         FROM usage_ledger ${where}
+         GROUP BY date ORDER BY date`).all(...bind);
+      const byModelRows = db.prepare(`SELECT provider, model, COUNT(*) as llmCalls,
+                COALESCE(SUM(totalTokens),0) as totalTokens,
+                COALESCE(SUM(estimatedCost),0) as totalCost
+         FROM usage_ledger ${where}
+         GROUP BY provider, model ORDER BY totalCost DESC`).all(...bind);
+      const byAgentRows = db.prepare(`SELECT agentId, COUNT(*) as llmCalls,
+                COALESCE(SUM(totalTokens),0) as totalTokens,
+                COALESCE(SUM(estimatedCost),0) as totalCost
+         FROM usage_ledger ${where}
+         GROUP BY agentId ORDER BY totalCost DESC`).all(...bind);
+      const bySessionRows = db.prepare(`SELECT sessionKey, agentId, model, COUNT(*) as llmCalls,
+                COALESCE(SUM(totalTokens),0) as totalTokens,
+                COALESCE(SUM(estimatedCost),0) as totalCost,
+                MIN(createdAt) as startedAt
+         FROM usage_ledger ${where}
+         GROUP BY sessionKey ORDER BY startedAt DESC`).all(...bind);
+      respond(true, {
+        totals: totalsRow,
+        daily: dailyRows,
+        byModel: byModelRows,
+        byAgent: byAgentRows,
+        bySession: bySessionRows
+      });
+    } catch (err) {
+      respond(false, { error: err?.message ?? "usage query error" });
+    }
+  }, { scope: "operator.read" });
+  api.registerGatewayMethod("agentlife.surfaceUsage", ({ params, respond }) => {
+    const surfaceId = typeof params?.surfaceId === "string" ? params.surfaceId.trim() : "";
+    if (!surfaceId)
+      return respond(false, { error: "missing surfaceId" });
+    try {
+      const db = getOrCreateHistoryDb(state);
+      const rows = db.prepare(`SELECT * FROM surface_usage WHERE surfaceId = ? ORDER BY createdAt DESC`).all(surfaceId);
+      const totals = rows.reduce((acc, r) => {
+        acc.inputTokens += r.inputTokens;
+        acc.outputTokens += r.outputTokens;
+        acc.cacheReadTokens += r.cacheReadTokens;
+        acc.cacheWriteTokens += r.cacheWriteTokens;
+        acc.totalTokens += r.totalTokens;
+        acc.estimatedCost += r.estimatedCost;
+        acc.llmCalls += r.llmCalls;
+        return acc;
+      }, { inputTokens: 0, outputTokens: 0, cacheReadTokens: 0, cacheWriteTokens: 0, totalTokens: 0, estimatedCost: 0, llmCalls: 0 });
+      respond(true, { surfaceId, entries: rows, totals });
+    } catch (err) {
+      respond(false, { error: err?.message ?? "surface usage error" });
+    }
+  }, { scope: "operator.read" });
+}
+
+// gateway/surfaces-gateway.ts
+function registerSurfacesGateway(api, state) {
+  api.registerGatewayMethod("agentlife.surfaces", ({ respond, context }) => {
+    captureBridge(context);
+    const now = Date.now();
+    const activeSurfaceIds = [];
+    const surfaceEntries = [];
+    if (!state.surfaceDb) {
+      respond(true, { surfaces: [] });
+      return;
+    }
+    const LOADING_TTL_MS = 2 * 60 * 1000;
+    for (const [surfaceId, meta] of state.surfaceDb.entries()) {
+      const headerLine = meta.lines[0] ?? "";
+      if (/\bstate=loading\b/.test(headerLine) && now - meta.updatedAt > LOADING_TTL_MS) {
+        const agentId = state.surfaceDb.getAgentId(surfaceId);
+        meta.lines[0] = headerLine.replace(/\bstate=loading\b/, "state=error");
+        state.surfaceDb.set(surfaceId, { ...meta, updatedAt: now });
+        recordSurfaceEvent(state, surfaceId, "loading_resolved_error", undefined, agentId ?? undefined, JSON.stringify({ reason: "loading surface orphaned (>2min)", resolvedBy: "surfaces_read" }));
+        console.log("[agentlife] resolved stale loading surface %s → error (stuck >2min)", surfaceId);
+      }
+    }
+    for (const [surfaceId, meta] of state.surfaceDb.entries()) {
+      if (isExpired(meta, now))
+        continue;
+      const headerLine = meta.lines[0] ?? "";
+      if (/\binput\b/.test(headerLine))
+        continue;
+      if (meta.lines.length > 0) {
+        surfaceEntries.push({ surfaceId, dsl: meta.lines.join(`
+`) });
+        activeSurfaceIds.push(surfaceId);
+      }
+    }
+    let usageMap;
+    if (activeSurfaceIds.length > 0) {
+      try {
+        const db = getOrCreateHistoryDb(state);
+        const placeholders = activeSurfaceIds.map(() => "?").join(",");
+        const rows = db.prepare(`SELECT surfaceId, SUM(totalTokens) as totalTokens, SUM(estimatedCost) as estimatedCost, SUM(llmCalls) as llmCalls
+           FROM surface_usage WHERE surfaceId IN (${placeholders}) GROUP BY surfaceId`).all(...activeSurfaceIds);
+        usageMap = new Map(rows.map((r) => [r.surfaceId, { totalTokens: r.totalTokens, estimatedCost: r.estimatedCost, llmCalls: r.llmCalls }]));
+      } catch {}
+    }
+    let viewedSet;
+    if (activeSurfaceIds.length > 0) {
+      try {
+        const db = getOrCreateHistoryDb(state);
+        const placeholders = activeSurfaceIds.map(() => "?").join(",");
+        const viewedRows = db.prepare(`SELECT DISTINCT surfaceId FROM surface_events WHERE event = 'detail_viewed' AND surfaceId IN (${placeholders})`).all(...activeSurfaceIds);
+        viewedSet = new Set(viewedRows.map((r) => r.surfaceId));
+      } catch {}
+    }
+    let followupCountMap;
+    let nextFollowupMap;
+    let automationsMap;
+    if (activeSurfaceIds.length > 0) {
+      try {
+        const db = getOrCreateHistoryDb(state);
+        const placeholders = activeSurfaceIds.map(() => "?").join(",");
+        const countRows = db.prepare(`SELECT surfaceId, COUNT(*) as c FROM surface_events WHERE event = 'cron_scheduled' AND surfaceId IN (${placeholders}) GROUP BY surfaceId`).all(...activeSurfaceIds);
+        followupCountMap = new Map(countRows.map((r) => [r.surfaceId, r.c]));
+        const followupRows = db.prepare(`SELECT id, surfaceId, fireAt, instruction, status FROM followups
+           WHERE surfaceId IN (${placeholders}) AND status = 'pending'
+           ORDER BY fireAt ASC`).all(...activeSurfaceIds);
+        nextFollowupMap = new Map;
+        for (const r of followupRows) {
+          if (!nextFollowupMap.has(r.surfaceId)) {
+            nextFollowupMap.set(r.surfaceId, { id: r.id, fireAt: r.fireAt, instruction: r.instruction, status: r.status });
+          }
+        }
+        const autoRows = db.prepare(`SELECT id, surfaceId, type, name, path, status FROM automations WHERE surfaceId IN (${placeholders}) AND status != 'removed'`).all(...activeSurfaceIds);
+        automationsMap = new Map;
+        for (const r of autoRows) {
+          const list = automationsMap.get(r.surfaceId) ?? [];
+          list.push({ id: r.id, type: r.type, name: r.name, path: r.path, status: r.status });
+          automationsMap.set(r.surfaceId, list);
+        }
+      } catch {}
+    }
+    let traceMap;
+    if (activeSurfaceIds.length > 0) {
+      try {
+        const db = getOrCreateHistoryDb(state);
+        const placeholders = activeSurfaceIds.map(() => "?").join(",");
+        const traceRows = db.prepare(`SELECT surfaceId, metadata FROM surface_events WHERE event = 'trace' AND surfaceId IN (${placeholders}) ORDER BY createdAt DESC`).all(...activeSurfaceIds);
+        traceMap = new Map;
+        for (const r of traceRows) {
+          if (!traceMap.has(r.surfaceId))
+            traceMap.set(r.surfaceId, r.metadata);
+        }
+      } catch {}
+    }
+    const surfaces = surfaceEntries.map((s) => {
+      const u = usageMap?.get(s.surfaceId);
+      const viewed = viewedSet?.has(s.surfaceId) ?? false;
+      const meta = state.surfaceDb.get(s.surfaceId);
+      const updatedAt = meta?.updatedAt ?? 0;
+      return {
+        ...s,
+        viewed,
+        updatedAt,
+        state: meta?.state ?? "active",
+        cronId: meta?.cronId ?? null,
+        followup: meta?.followup ?? null,
+        goal: meta?.goal ?? null,
+        context: meta?.context ?? null,
+        followupCount: followupCountMap?.get(s.surfaceId) ?? 0,
+        nextFollowup: nextFollowupMap?.get(s.surfaceId) ?? null,
+        trace: traceMap?.get(s.surfaceId) ?? null,
+        automations: automationsMap?.get(s.surfaceId) ?? [],
+        ...u ? { usage: u } : {}
+      };
+    });
+    respond(true, { surfaces });
+  }, { scope: "operator.read" });
+  api.registerGatewayMethod("agentlife.dismiss", ({ params, respond }) => {
+    const surfaceId = params?.surfaceId;
+    if (!surfaceId || typeof surfaceId !== "string") {
+      respond(false, { error: "missing surfaceId" });
+      return;
+    }
+    const meta = state.surfaceDb?.get(surfaceId);
+    if (!meta) {
+      respond(true, { surfaceId, dismissed: false });
+      return;
+    }
+    const agentId = state.surfaceDb.getAgentId(surfaceId) ?? null;
+    const cronId = state.surfaceDb.getCronId(surfaceId);
+    recordSurfaceEvent(state, surfaceId, "dismissed", undefined, agentId ?? undefined);
+    let automations = [];
+    try {
+      const db = getOrCreateHistoryDb(state);
+      automations = db.prepare("SELECT id, type, name, path FROM automations WHERE surfaceId = ? AND status != 'removed'").all(surfaceId);
+    } catch {}
+    state.surfaceDb.delete(surfaceId);
+    broadcastDelete(surfaceId);
+    try {
+      enqueueCleanupTasks(state, surfaceId, agentId, cronId, automations);
+    } catch (err) {
+      console.error("[agentlife] dismiss: failed to enqueue cleanup tasks for %s: %s", surfaceId, err?.message);
+    }
+    const taskCount = (cronId ? 1 : 0) + (agentId ? 1 : 0);
+    console.log("[agentlife] dismiss: %s deleted, %d cleanup tasks enqueued", surfaceId, taskCount);
+    respond(true, { surfaceId, dismissed: true });
+    processCleanupTasks(state, surfaceId).catch((e) => console.warn("[agentlife] dismiss cleanup processor error:", e?.message));
+  }, { scope: "operator.write" });
+  api.registerGatewayMethod("agentlife.engage", ({ params, respond }) => {
+    const surfaceId = typeof params?.surfaceId === "string" ? params.surfaceId.trim() : "";
+    const event = typeof params?.event === "string" ? params.event.trim() : "";
+    if (!surfaceId || !event) {
+      respond(false, { error: "missing surfaceId or event" });
+      return;
+    }
+    const agentId = state.surfaceDb?.getAgentId(surfaceId);
+    const metadata = typeof params?.metadata === "string" ? params.metadata.trim() : undefined;
+    recordSurfaceEvent(state, surfaceId, event, undefined, agentId, metadata);
+    respond(true, { surfaceId, event });
+  }, { scope: "operator.read" });
+  api.registerGatewayMethod("agentlife.input", ({ params, respond }) => {
+    const message = typeof params?.message === "string" ? params.message : "";
+    const sessionKey = typeof params?.sessionKey === "string" ? params.sessionKey : "";
+    if (!message) {
+      respond(false, { error: "missing message" });
+      return;
+    }
+    broadcastInput(message, sessionKey);
+    respond(true, { broadcast: true });
+  }, { scope: "operator.write" });
+  api.registerGatewayMethod("agentlife.action", ({ params, respond }) => {
+    const surfaceId = typeof params?.surfaceId === "string" ? params.surfaceId.trim() : "";
+    if (!surfaceId) {
+      respond(false, { error: "missing surfaceId" });
+      return;
+    }
+    const agentId = state.surfaceDb?.getAgentId(surfaceId) ?? null;
+    const sessionKey = agentId ? `agent:${agentId}:main` : null;
+    console.log("[agentlife] action target: surface=%s agent=%s session=%s", surfaceId, agentId ?? "unknown", sessionKey ?? "orchestrator");
+    respond(true, { surfaceId, agentId, sessionKey });
+  }, { scope: "operator.read" });
+}
+
+// gateway/automations.ts
+function registerAutomationsGateway(api, state) {
+  api.registerGatewayMethod("agentlife.automations.register", ({ params, respond }) => {
+    try {
+      const type = typeof params?.type === "string" ? params.type.trim() : "";
+      const name = typeof params?.name === "string" ? params.name.trim() : "";
+      const automationPath = typeof params?.path === "string" ? params.path.trim() : "";
+      if (!type || !name || !automationPath) {
+        respond(false, { error: "missing required fields: type, name, path" });
+        return;
+      }
+      const surfaceId = typeof params?.surfaceId === "string" ? params.surfaceId.trim() : "";
+      const agentId = typeof params?.agentId === "string" ? params.agentId.trim() : state.surfaceDb?.getAgentId(surfaceId) ?? "";
+      const id = registerAutomation(state, { surfaceId, agentId, type, name, path: automationPath });
+      respond(true, { id, surfaceId, agentId, type, name, path: automationPath, status: "running" });
+    } catch (err) {
+      respond(false, { error: err?.message ?? "register failed" });
+    }
+  }, { scope: "operator.write" });
+  api.registerGatewayMethod("agentlife.automations.list", ({ params, respond }) => {
+    try {
+      const db = getOrCreateHistoryDb(state);
+      let sql = "SELECT * FROM automations WHERE 1=1";
+      const sqlParams = [];
+      const surfaceId = typeof params?.surfaceId === "string" ? params.surfaceId.trim() : "";
+      if (surfaceId) {
+        sql += " AND surfaceId = ?";
+        sqlParams.push(surfaceId);
+      }
+      const agentId = typeof params?.agentId === "string" ? params.agentId.trim() : "";
+      if (agentId) {
+        sql += " AND agentId = ?";
+        sqlParams.push(agentId);
+      }
+      const status = typeof params?.status === "string" ? params.status.trim() : "";
+      if (status) {
+        sql += " AND status = ?";
+        sqlParams.push(status);
+      } else {
+        sql += " AND status != 'removed'";
+      }
+      sql += " ORDER BY updatedAt DESC";
+      const rows = db.prepare(sql).all(...sqlParams);
+      respond(true, {
+        automations: rows.map((r) => ({
+          id: r.id,
+          surfaceId: r.surfaceId,
+          agentId: r.agentId,
+          type: r.type,
+          name: r.name,
+          path: r.path,
+          status: r.status,
+          createdAt: r.createdAt,
+          updatedAt: r.updatedAt
+        }))
+      });
+    } catch (err) {
+      respond(false, { error: err?.message ?? "list failed" });
+    }
+  }, { scope: "operator.read" });
+  api.registerGatewayMethod("agentlife.automations.update", ({ params, respond }) => {
+    try {
+      const id = typeof params?.id === "number" ? params.id : parseInt(params?.id, 10);
+      const status = typeof params?.status === "string" ? params.status.trim() : "";
+      if (!id || !status || !["running", "stopped", "error"].includes(status)) {
+        respond(false, { error: "missing id or invalid status (running|stopped|error)" });
+        return;
+      }
+      const db = getOrCreateHistoryDb(state);
+      db.prepare("UPDATE automations SET status = ?, updatedAt = ? WHERE id = ?").run(status, Date.now(), id);
+      respond(true, { id, status });
+    } catch (err) {
+      respond(false, { error: err?.message ?? "update failed" });
+    }
+  }, { scope: "operator.write" });
+  api.registerGatewayMethod("agentlife.automations.remove", ({ params, respond }) => {
+    try {
+      const id = typeof params?.id === "number" ? params.id : parseInt(params?.id, 10);
+      if (!id) {
+        respond(false, { error: "missing id" });
+        return;
+      }
+      const db = getOrCreateHistoryDb(state);
+      db.prepare("UPDATE automations SET status = 'removed', updatedAt = ? WHERE id = ?").run(Date.now(), id);
+      respond(true, { id, status: "removed" });
+    } catch (err) {
+      respond(false, { error: err?.message ?? "remove failed" });
+    }
+  }, { scope: "operator.write" });
+}
+
+// gateway/admin.ts
+import * as fs6 from "node:fs/promises";
+import * as os3 from "node:os";
+import * as path9 from "node:path";
+function registerAdminGateway(api, state) {
+  api.registerGatewayMethod("agentlife.quality", ({ respond }) => {
+    try {
+      const db = getOrCreateHistoryDb(state);
+      const totalWarnings = db.prepare("SELECT COUNT(*) as c FROM surface_events WHERE event='quality_warning'").get()?.c ?? 0;
+      const warningsByType = {};
+      const rows = db.prepare("SELECT surfaceId, agentId, metadata, createdAt FROM surface_events WHERE event='quality_warning' ORDER BY createdAt DESC").all();
+      const warnings = [];
+      for (const row of rows) {
+        try {
+          const meta = JSON.parse(row.metadata);
+          const issues = meta.issues ?? [];
+          for (const issue of issues) {
+            warningsByType[issue] = (warningsByType[issue] ?? 0) + 1;
+          }
+          warnings.push({ surfaceId: row.surfaceId, agentId: row.agentId ?? null, issues, sessionKey: meta.sessionKey ?? null, createdAt: row.createdAt });
+        } catch {}
+      }
+      const warningsByAgent = {};
+      const agentRows = db.prepare("SELECT agentId, COUNT(*) as c FROM surface_events WHERE event='quality_warning' AND agentId IS NOT NULL GROUP BY agentId").all();
+      for (const r of agentRows) {
+        warningsByAgent[r.agentId] = r.c;
+      }
+      const cronScheduled = db.prepare("SELECT COUNT(*) as c FROM surface_events WHERE event='cron_scheduled'").get()?.c ?? 0;
+      const cronFired = db.prepare("SELECT COUNT(*) as c FROM surface_events WHERE event='cron_fired'").get()?.c ?? 0;
+      const cronRemoved = db.prepare("SELECT COUNT(*) as c FROM surface_events WHERE event='cron_removed'").get()?.c ?? 0;
+      const cleanupPending = db.prepare("SELECT COUNT(*) as c FROM cleanup_tasks WHERE status IN ('pending', 'running')").get()?.c ?? 0;
+      const cleanupFailed = db.prepare("SELECT COUNT(*) as c FROM cleanup_tasks WHERE status = 'failed' AND attempts < maxAttempts").get()?.c ?? 0;
+      const cleanupExhausted = db.prepare("SELECT COUNT(*) as c FROM cleanup_tasks WHERE status = 'failed' AND attempts >= maxAttempts").get()?.c ?? 0;
+      respond(true, {
+        totalWarnings,
+        warningsByType,
+        warningsByAgent,
+        warnings,
+        cron: { scheduled: cronScheduled, fired: cronFired, removed: cronRemoved },
+        cleanup: { pending: cleanupPending, failed: cleanupFailed, exhausted: cleanupExhausted }
+      });
+    } catch (err) {
+      respond(false, { error: err?.message ?? "quality metrics unavailable" });
+    }
+  }, { scope: "operator.read" });
+  api.registerGatewayMethod("agentlife.bootstrap", ({ params, respond }) => {
+    const sessionKey = typeof params?.sessionKey === "string" ? params.sessionKey.trim() : null;
+    const agentId = typeof params?.agentId === "string" ? params.agentId.trim() : null;
+    let snapshot = [];
+    if (sessionKey) {
+      snapshot = state.sessionBootstrapSnapshots.get(sessionKey) ?? [];
+    }
+    if (snapshot.length === 0 && agentId) {
+      const prefix = `agent:${agentId}:`;
+      for (const [key, files] of state.sessionBootstrapSnapshots.entries()) {
+        if (key.startsWith(prefix)) {
+          snapshot = files;
+          break;
+        }
+      }
+    }
+    if (snapshot.length === 0) {
+      const fromDb = loadBootstrapSnapshot(state, sessionKey ?? "", agentId);
+      if (fromDb && fromDb.length > 0)
+        snapshot = fromDb;
+    }
+    if (snapshot.length === 0) {
+      respond(true, { status: "no bootstrap snapshot for this session", files: [], availableSessions: [...state.sessionBootstrapSnapshots.keys()] });
+      return;
+    }
+    respond(true, {
+      files: snapshot.map((f) => ({
+        name: f.name,
+        path: f.path,
+        missing: f.missing,
+        bytes: (f.content ?? "").length,
+        content: f.content ?? ""
+      }))
+    });
+  }, { scope: "operator.read" });
+  api.registerGatewayMethod("agentlife.uninstall", async ({ respond }) => {
+    try {
+      const cleaned = [];
+      const baseDir = state.agentlifeStateDir ?? path9.join(os3.homedir(), ".openclaw", "agentlife");
+      if (state.runCommand) {
+        try {
+          const result = await state.runCommand(["openclaw", "cron", "list", "--json"], { timeoutMs: 1e4 });
+          if (result?.code === 0) {
+            const stdout = typeof result.stdout === "string" ? result.stdout : "";
+            const jsonStart = stdout.indexOf("{");
+            const data = jsonStart >= 0 ? JSON.parse(stdout.slice(jsonStart)) : null;
+            const jobs = [...data?.jobs ?? []];
+            const provisionedIds = new Set(PROVISIONED_AGENTS.map((a) => a.id));
+            for (const job of jobs) {
+              if (job.agentId && provisionedIds.has(job.agentId)) {
+                try {
+                  await state.runCommand(["openclaw", "cron", "rm", String(job.id)], { timeoutMs: 5000 });
+                  cleaned.push(`deleted cron job ${job.id} (${job.name ?? job.agentId})`);
+                } catch {}
+              }
+            }
+          }
+        } catch {
+          cleaned.push("cron cleanup skipped (CLI unavailable)");
+        }
+      }
+      try {
+        const cfg = api.runtime.config.loadConfig();
+        const agentList = cfg?.agents?.list ?? [];
+        if (Array.isArray(agentList)) {
+          const provisionedIds = new Set(PROVISIONED_AGENTS.filter((a) => !a.existingAgent).map((a) => a.id));
+          const filtered = agentList.filter((a) => !provisionedIds.has(a.id));
+          if (filtered.length !== agentList.length) {
+            cfg.agents.list = filtered;
+            await api.runtime.config.writeConfigFile(cfg);
+            cleaned.push(`removed ${agentList.length - filtered.length} provisioned agents from config`);
+          }
+        }
+      } catch {
+        cleaned.push("agent config cleanup skipped");
+      }
+      const backupPath = path9.join(baseDir, "config-backup.json");
+      try {
+        cleaned.push(await restoreConfigFromBackup(api, backupPath));
+      } catch {
+        cleaned.push("maxPingPongTurns already at default (no backup found)");
+      }
+      stopFollowupSystem();
+      if (state.surfaceDb)
+        state.surfaceDb.clear();
+      closeAllDbs(state);
+      state.agentRegistry.clear();
+      state.usageAccumulator.clear();
+      state.sessionBootstrapSnapshots.clear();
+      state.pendingFollowups.clear();
+      state.surfaceDb = null;
+      state.disabled = true;
+      cleaned.push("stopped runtime (poller, DBs, in-memory state)");
+      const dbPath = state.historyDbPath;
+      const stateFiles = [
+        state.registryFilePath,
+        dbPath,
+        dbPath ? `${dbPath}-wal` : null,
+        dbPath ? `${dbPath}-shm` : null,
+        path9.join(baseDir, "config-backup.json"),
+        path9.join(baseDir, "notification-config.json"),
+        path9.join(baseDir, "canvas-node-identity.json")
+      ].filter(Boolean);
+      for (const fp of stateFiles) {
+        try {
+          await fs6.unlink(fp);
+          cleaned.push(`deleted ${path9.basename(fp)}`);
+        } catch {}
+      }
+      if (state.dbBaseDir) {
+        try {
+          await fs6.rm(state.dbBaseDir, { recursive: true, force: true });
+          cleaned.push("deleted agent databases");
+        } catch {}
+      }
+      for (const agent of PROVISIONED_AGENTS) {
+        if (agent.existingAgent)
+          continue;
+        const wsDir = agent.workspaceDir ?? path9.join(os3.homedir(), ".openclaw", `workspace-${agent.id}`);
+        try {
+          await fs6.rm(wsDir, { recursive: true, force: true });
+          cleaned.push(`deleted workspace ${agent.id}`);
+        } catch {}
+      }
+      try {
+        const remaining = await fs6.readdir(baseDir);
+        if (remaining.length === 0) {
+          await fs6.rmdir(baseDir);
+          cleaned.push("deleted agentlife state directory");
+        }
+      } catch {}
+      console.log("[agentlife] uninstall: cleanup complete — %s", cleaned.join(", "));
+      respond(true, {
+        cleaned,
+        nextStep: "Run `openclaw plugins uninstall agentlife` to remove the plugin code, then restart the gateway."
+      });
+    } catch (err) {
+      console.error("[agentlife] uninstall failed:", err);
+      respond(false, { error: err?.message ?? "unknown error during uninstall" });
+    }
+  });
+}
+
+// gateway/followups-gateway.ts
+function registerFollowupsGateway(api, state) {
+  api.registerGatewayMethod("agentlife.followups", ({ params, respond }) => {
+    const action = typeof params?.action === "string" ? params.action : "list";
+    switch (action) {
+      case "list":
+        return handleList(state, params, respond);
+      case "cancel":
+        return handleCancel(state, params, respond);
+      case "run":
+        return handleRun(state, params, respond);
+      case "edit":
+        return handleEdit(state, params, respond);
+      default:
+        respond(false, undefined, { code: "INVALID_ACTION", message: `Unknown action: ${action}` });
+    }
+  }, { scope: "operator.write" });
+}
+function handleList(state, params, respond) {
+  try {
+    const db = getOrCreateHistoryDb(state);
+    const surfaceId = typeof params?.surfaceId === "string" ? params.surfaceId : null;
+    const cutoff = Date.now() - 24 * 60 * 60 * 1000;
+    let rows;
+    if (surfaceId) {
+      rows = db.prepare(`SELECT id, surfaceId, agentId, fireAt, instruction, status, createdAt
+         FROM followups
+         WHERE surfaceId = ? AND (status = 'pending' OR createdAt > ?)
+         ORDER BY fireAt DESC`).all(surfaceId, cutoff);
+    } else {
+      rows = db.prepare(`SELECT id, surfaceId, agentId, fireAt, instruction, status, createdAt
+         FROM followups
+         WHERE status = 'pending' OR createdAt > ?
+         ORDER BY fireAt DESC`).all(cutoff);
+    }
+    respond(true, {
+      followups: rows.map((r) => {
+        const meta = state.surfaceDb?.get(r.surfaceId);
+        const title = meta ? extractTitleAndDetail(meta).title : null;
+        const goal = meta?.goal ?? null;
+        return {
+          id: r.id,
+          surfaceId: r.surfaceId,
+          agentId: r.agentId,
+          fireAt: r.fireAt,
+          instruction: r.instruction,
+          status: r.status,
+          createdAt: r.createdAt,
+          widgetTitle: title,
+          goal
+        };
+      })
+    });
+  } catch (e) {
+    console.error("[agentlife:followups-gw] list error:", e?.message);
+    respond(false, undefined, { code: "LIST_ERROR", message: e?.message });
+  }
+}
+function handleCancel(state, params, respond) {
+  const id = typeof params?.id === "number" ? params.id : null;
+  if (id == null) {
+    respond(false, undefined, { code: "MISSING_ID", message: "id is required" });
+    return;
+  }
+  try {
+    const db = getOrCreateHistoryDb(state);
+    const row = db.prepare("SELECT surfaceId, status FROM followups WHERE id = ?").get(id);
+    if (!row) {
+      respond(false, undefined, { code: "NOT_FOUND", message: `Followup ${id} not found` });
+      return;
+    }
+    if (row.status !== "pending") {
+      respond(false, undefined, { code: "NOT_PENDING", message: `Followup ${id} is ${row.status}, not pending` });
+      return;
+    }
+    db.prepare("UPDATE followups SET status = 'cancelled' WHERE id = ?").run(id);
+    state.surfaceDb?.setCronId(row.surfaceId, null);
+    recordSurfaceEvent(state, row.surfaceId, "followup_cancelled", undefined, undefined, JSON.stringify({ followupId: id }));
+    console.log("[agentlife:followups-gw] cancelled followup %d for %s", id, row.surfaceId);
+    respond(true, { id, cancelled: true });
+  } catch (e) {
+    console.error("[agentlife:followups-gw] cancel error:", e?.message);
+    respond(false, undefined, { code: "CANCEL_ERROR", message: e?.message });
+  }
+}
+function handleRun(state, params, respond) {
+  const id = typeof params?.id === "number" ? params.id : null;
+  if (id == null) {
+    respond(false, undefined, { code: "MISSING_ID", message: "id is required" });
+    return;
+  }
+  try {
+    const db = getOrCreateHistoryDb(state);
+    const row = db.prepare("SELECT surfaceId, agentId, instruction, status FROM followups WHERE id = ?").get(id);
+    if (!row) {
+      respond(false, undefined, { code: "NOT_FOUND", message: `Followup ${id} not found` });
+      return;
+    }
+    if (row.status !== "pending") {
+      respond(false, undefined, { code: "NOT_PENDING", message: `Followup ${id} is ${row.status}, not pending` });
+      return;
+    }
+    db.prepare("UPDATE followups SET status = 'fired' WHERE id = ?").run(id);
+    const agentId = row.agentId ?? state.surfaceDb?.getAgentId(row.surfaceId) ?? null;
+    if (!agentId) {
+      respond(false, undefined, { code: "NO_AGENT", message: "Cannot resolve agent for surface" });
+      return;
+    }
+    const sessionKey = `agent:${agentId}:main`;
+    fireFollowupViaChat(state, sessionKey, row.instruction, row.surfaceId);
+    recordSurfaceEvent(state, row.surfaceId, "cron_fired", undefined, agentId, JSON.stringify({ followupId: id, manual: true }));
+    console.log("[agentlife:followups-gw] manually fired followup %d → %s", id, sessionKey);
+    respond(true, { id, fired: true });
+  } catch (e) {
+    console.error("[agentlife:followups-gw] run error:", e?.message);
+    respond(false, undefined, { code: "RUN_ERROR", message: e?.message });
+  }
+}
+function fireFollowupViaChat(state, sessionKey, instruction, surfaceId) {
+  if (!state.runCommand) {
+    console.warn("[agentlife:followups-gw] runCommand not available — cannot fire followup");
+    return;
+  }
+  const idempotencyKey = `followup-${surfaceId}-${Date.now()}`;
+  const params = JSON.stringify({ sessionKey, message: `[system] ${instruction}`, idempotencyKey });
+  state.runCommand(["openclaw", "gateway", "call", "chat.send", "--params", params], { timeoutMs: 60000 }).then((result) => {
+    console.log("[agentlife:followups-gw] chat.send result: code=%s", result?.code ?? "?");
+  }).catch((e) => {
+    console.error("[agentlife:followups-gw] chat.send failed: %s", e?.message);
+  });
+}
+function handleEdit(state, params, respond) {
+  const id = typeof params?.id === "number" ? params.id : null;
+  if (id == null) {
+    respond(false, undefined, { code: "MISSING_ID", message: "id is required" });
+    return;
+  }
+  const delay = typeof params?.delay === "string" ? params.delay.trim() : null;
+  const instruction = typeof params?.instruction === "string" ? params.instruction.trim() : null;
+  if (!delay && !instruction) {
+    respond(false, undefined, { code: "NO_CHANGES", message: "Provide delay and/or instruction" });
+    return;
+  }
+  try {
+    const db = getOrCreateHistoryDb(state);
+    const row = db.prepare("SELECT surfaceId, agentId, fireAt, instruction, status FROM followups WHERE id = ?").get(id);
+    if (!row) {
+      respond(false, undefined, { code: "NOT_FOUND", message: `Followup ${id} not found` });
+      return;
+    }
+    if (row.status !== "pending") {
+      respond(false, undefined, { code: "NOT_PENDING", message: `Followup ${id} is ${row.status}, not pending` });
+      return;
+    }
+    let newFireAt = row.fireAt;
+    if (delay) {
+      const offsetMs = parseOffset2(delay);
+      if (offsetMs <= 0) {
+        respond(false, undefined, { code: "INVALID_DELAY", message: `Cannot parse delay: ${delay}` });
+        return;
+      }
+      newFireAt = Date.now() + offsetMs;
+    }
+    const newInstruction = instruction ?? row.instruction;
+    db.prepare("UPDATE followups SET fireAt = ?, instruction = ? WHERE id = ?").run(newFireAt, newInstruction, id);
+    recordSurfaceEvent(state, row.surfaceId, "followup_edited", undefined, row.agentId ?? undefined, JSON.stringify({ followupId: id, delay, instruction: instruction ? "(updated)" : null }));
+    console.log("[agentlife:followups-gw] edited followup %d: fireAt=%d", id, newFireAt);
+    respond(true, {
+      followup: {
+        id,
+        surfaceId: row.surfaceId,
+        agentId: row.agentId,
+        fireAt: newFireAt,
+        instruction: newInstruction,
+        status: "pending",
+        createdAt: row.createdAt
+      }
+    });
+  } catch (e) {
+    console.error("[agentlife:followups-gw] edit error:", e?.message);
+    respond(false, undefined, { code: "EDIT_ERROR", message: e?.message });
+  }
+}
+function parseOffset2(offset) {
+  const match = offset.match(/^\+?(\d+)(ms|s|m|h|d)$/);
+  if (!match)
+    return 0;
+  const val = parseInt(match[1], 10);
+  switch (match[2]) {
+    case "ms":
+      return val;
+    case "s":
+      return val * 1000;
+    case "m":
+      return val * 60000;
+    case "h":
+      return val * 3600000;
+    case "d":
+      return val * 86400000;
+    default:
+      return 0;
+  }
+}
+
+// gateway/web-app.ts
+import * as path10 from "node:path";
+import * as fs7 from "node:fs";
+var MIME_TYPES = {
+  ".html": "text/html; charset=utf-8",
+  ".js": "application/javascript",
+  ".mjs": "application/javascript",
+  ".wasm": "application/wasm",
+  ".css": "text/css",
+  ".json": "application/json",
+  ".png": "image/png",
+  ".svg": "image/svg+xml",
+  ".ico": "image/x-icon",
+  ".txt": "text/plain",
+  ".map": "application/json"
+};
+function registerWebApp(api) {
+  const pluginRoot = path10.resolve(path10.dirname(api.source), "..");
+  const appRoot = path10.join(pluginRoot, "web-build");
+  if (!fs7.existsSync(appRoot)) {
+    api.logger.info("[agentlife] web-build/ not found — /agentlife/ route not registered");
+    return;
+  }
+  const indexPath = path10.join(appRoot, "index.html");
+  if (!fs7.existsSync(indexPath)) {
+    api.logger.warn("[agentlife] web-build/index.html missing — /agentlife/ route not registered");
+    return;
+  }
+  let gatewayToken = "";
+  try {
+    const configPath = path10.join(__require("node:os").homedir(), ".openclaw", "openclaw.json");
+    const raw = JSON.parse(fs7.readFileSync(configPath, "utf-8"));
+    gatewayToken = raw?.gateway?.auth?.token || "";
+  } catch {}
+  const approveLatest = () => {
+    try {
+      const { execSync } = __require("node:child_process");
+      execSync("openclaw devices approve --latest", { timeout: 5000, stdio: "ignore" });
+    } catch {}
+  };
+  api.registerHttpRoute({
+    path: "/agentlife",
+    match: "prefix",
+    auth: "plugin",
+    handler: (req, res) => {
+      const urlPath = new URL(req.url || "/", "http://localhost").pathname;
+      const relative = urlPath.replace(/^\/agentlife\/?/, "") || "index.html";
+      const filePath = path10.resolve(appRoot, relative);
+      if (!filePath.startsWith(appRoot)) {
+        res.writeHead(403);
+        res.end();
+        return true;
+      }
+      const target = fs7.existsSync(filePath) && fs7.statSync(filePath).isFile() ? filePath : indexPath;
+      const ext = path10.extname(target).toLowerCase();
+      const contentType = MIME_TYPES[ext] || "application/octet-stream";
+      let content = fs7.readFileSync(target);
+      if (target === indexPath) {
+        setTimeout(approveLatest, 2000);
+        setTimeout(approveLatest, 5000);
+        if (gatewayToken) {
+          const injection = `<script>window.__GATEWAY_TOKEN__="${gatewayToken}";</script>`;
+          const html = content.toString().replace("</head>", injection + "</head>");
+          content = Buffer.from(html);
+        }
+      }
+      res.writeHead(200, {
+        "Content-Type": contentType,
+        "Content-Length": content.length,
+        "Cache-Control": ext === ".html" ? "no-cache" : "public, max-age=86400"
+      });
+      res.end(content);
+      return true;
+    }
+  });
+  api.logger.info("[agentlife] /agentlife/ route registered — serving WASM web app");
+}
+
+// index.ts
+var currentState = null;
+function _closeAllDbs() {
+  if (currentState)
+    closeAllDbs(currentState);
+}
+function _getState() {
+  if (!currentState)
+    throw new Error("plugin not registered");
+  return currentState;
+}
+function register(api) {
+  const fallbackDir = path11.join(homedir4(), ".openclaw", "agentlife");
+  const state = {
+    surfaceDb: null,
+    agentRegistry: new Map,
+    usageAccumulator: new Map,
+    sessionBootstrapSnapshots: new Map,
+    pendingFollowups: new Map,
+    agentDbs: new Map,
+    historyDb: null,
+    agentlifeStateDir: fallbackDir,
+    registryFilePath: path11.join(fallbackDir, "agent-registry.json"),
+    dbBaseDir: path11.join(fallbackDir, "db"),
+    historyDbPath: path11.join(fallbackDir, "agentlife.db"),
+    runCommand: api.runtime.system?.runCommandWithTimeout ?? null,
+    enqueueSystemEvent: null,
+    requestHeartbeatNow: null,
+    disabled: false
+  };
+  currentState = state;
+  if (existsSync4(fallbackDir)) {
+    try {
+      const db = getOrCreateHistoryDb(state);
+      state.surfaceDb = new SurfaceDb(db);
+    } catch (e) {
+      console.warn("[agentlife] eager surface DB init failed:", e?.message);
+    }
+    loadRegistryFromDisk(state).catch((e) => console.warn("[agentlife] eager registry load failed:", e?.message));
+  }
+  registerSurfacesService(api, state);
+  api.registerService({
+    id: "agentlife-provisioning",
+    start: async () => {
+      const cfg = api.runtime.config.loadConfig();
+      await provisionAgents(state, cfg, api.runtime, console.log);
+    }
+  });
+  registerConfigOptimizer(api, state);
+  registerPairingServices(api);
+  api.registerService({
+    id: "agentlife-shutdown",
+    start: () => {},
+    stop: () => {
+      stopFollowupSystem();
+      closeAllDbs(state);
+    }
+  });
+  initFollowupSystem(api, state);
+  registerBootstrapHook(api, state);
+  registerPromptStateHook(api, state);
+  registerWidgetPushTool(api, state);
+  registerActivityHooks(api, state);
+  registerAgentGateway(api, state);
+  registerDbGateway(api, state);
+  registerHistoryGateway(api, state);
+  registerUsageGateway(api, state);
+  registerSurfacesGateway(api, state);
+  registerAutomationsGateway(api, state);
+  registerFollowupsGateway(api, state);
+  registerAdminGateway(api, state);
+  registerWebApp(api);
+  const notifyConfigPath = path11.join(fallbackDir, "notification-config.json");
+  api.registerGatewayMethod("agentlife.notifications.register", ({ params, respond }) => {
+    const serverUrl = typeof params?.serverUrl === "string" ? params.serverUrl.trim() : "";
+    const apiKey = typeof params?.apiKey === "string" ? params.apiKey.trim() : "";
+    if (!serverUrl || !apiKey) {
+      return respond(false, { error: "missing serverUrl or apiKey" });
+    }
+    try {
+      const { writeFileSync: writeFileSync2, mkdirSync: mkdirSync2 } = __require("node:fs");
+      mkdirSync2(path11.dirname(notifyConfigPath), { recursive: true });
+      writeFileSync2(notifyConfigPath, JSON.stringify({ serverUrl, apiKey }));
+    } catch {}
+    respond(true, { registered: true });
+  }, { scope: "operator.write" });
+}
+export {
+  register as default,
+  _getState,
+  _closeAllDbs
+};