agentlife 1.3.2 → 1.4.1

package/dist/index.js

@@ -2,8 +2,8 @@ import { createRequire } from "node:module";
 var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
 // index.ts
-import { homedir as homedir9 } from "node:os";
-import * as path13 from "node:path";
+import { homedir as homedir11 } from "node:os";
+import * as path15 from "node:path";
 import { existsSync as existsSync6 } from "node:fs";
 
 // db.ts
@@ -193,6 +193,31 @@ function getOrCreateHistoryDb(state) {
     );
     CREATE INDEX IF NOT EXISTS idx_pqc_createdAt ON pending_quality_checks(createdAt);
 
+    CREATE TABLE IF NOT EXISTS cold_start_state (
+      id                  INTEGER PRIMARY KEY CHECK (id = 1),
+      phase               TEXT    NOT NULL,
+      enteredAt           INTEGER NOT NULL,
+      lastActionAt        INTEGER,
+      ackAt               INTEGER,
+      deadlineAt          INTEGER,
+      retryCount          INTEGER NOT NULL DEFAULT 0,
+      failureReason       TEXT,
+      lastTrigger         TEXT,
+      actionSessionKey    TEXT,
+      contractWarnings    TEXT,
+      pollerLastTickAt    INTEGER,
+      updatedAt           INTEGER NOT NULL
+    );
+
+    CREATE TABLE IF NOT EXISTS cold_start_triggers (
+      id        INTEGER PRIMARY KEY AUTOINCREMENT,
+      kind      TEXT    NOT NULL,
+      payload   TEXT    NOT NULL,
+      createdAt INTEGER NOT NULL
+    );
+    CREATE INDEX IF NOT EXISTS idx_cold_start_triggers_createdAt
+      ON cold_start_triggers(createdAt);
+
 `);
   try {
     state.historyDb.exec("ALTER TABLE surfaces ADD COLUMN cronId TEXT");
@@ -203,6 +228,9 @@ function getOrCreateHistoryDb(state) {
   try {
     state.historyDb.exec("ALTER TABLE surfaces ADD COLUMN originSessionKey TEXT");
   } catch {}
+  try {
+    state.historyDb.exec("ALTER TABLE surfaces ADD COLUMN dashboardVisible INTEGER NOT NULL DEFAULT 1");
+  } catch {}
   try {
     const moved = state.historyDb.prepare(`
       INSERT INTO activity_log (ts, sessionKey, agentId, event, data)
@@ -324,6 +352,13 @@ class SurfaceDb {
   setState(id, state) {
     this.db.prepare("UPDATE surfaces SET state = ? WHERE surfaceId = ?").run(state, id);
   }
+  getDashboardVisible(id) {
+    const row = this.db.prepare("SELECT dashboardVisible FROM surfaces WHERE surfaceId = ?").get(id);
+    return row?.dashboardVisible !== 0;
+  }
+  setDashboardVisible(id, visible) {
+    this.db.prepare("UPDATE surfaces SET dashboardVisible = ? WHERE surfaceId = ?").run(visible ? 1 : 0, 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 }));
@@ -736,6 +771,28 @@ When receiving via sessions_send: push widgets with results. If nothing to push,
 
 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.
 
+### \`[system:start]\` — First-Run Baseline Capture
+
+When you receive \`[system:start]\` on your direct session, you were just created by the builder. You have zero memory about this user. Your one-turn job:
+
+1. Push a loading widget (\`state=loading\`) introducing yourself per \`IDENTITY.md\`.
+2. Push ONE \`input\` surface asking the most important baseline question for your domain. Use button choices where possible; offer a textfield for open-ended answers. The final widget push (non-loading) can be the input surface itself.
+3. Respond \`done\`.
+
+On each subsequent \`[action:choice]\` or \`[action:submit]\` referencing a \`warmup-*\` surfaceId you pushed:
+1. Append the answer to \`memory/baseline.md\` in your workspace via \`exec\` (create the \`memory/\` directory if missing). This file persists across sessions and feeds \`[system:dashboard-bootstrap]\`.
+2. Delete the answered input surface.
+3. Push the NEXT baseline question as a new \`warmup-*\` input surface, OR — if you've asked enough to establish a meaningful baseline for your domain — stop.
+4. Respond \`done\`.
+
+Rules:
+- 2-4 total questions, one at a time. Never ask multiple questions in a single surface.
+- Questions must be domain-relevant baseline — the minimum your domain needs to personalize first recommendations. Your AGENTS.md defines what baseline matters.
+- Capture answers via \`exec\` writing to \`memory/baseline.md\`. Do NOT rely on session history — baseline must persist.
+- No dashboard widgets in this flow beyond the intro + input surfaces. Domain work starts after baseline.
+- Match the user's language.
+- If \`memory/baseline.md\` already exists and is non-empty on entry, skip the questions and respond \`done\`.
+
 `;
 var INTERNAL_AGENTS_MD = `
 ## Internal Session — Self-Improvement Protocol
@@ -1253,64 +1310,6 @@ When you receive "Enrich agent registry descriptions" — system task, no widget
 
 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".
 
-## Dashboard Bootstrap
-
-When you receive "[system:dashboard-bootstrap]" — this is a different mode from agent creation.
-
-Your task is to create vision widgets, NOT to create or modify agents. The message contains the user's data inline and the widget structure. Read the data, follow the structure, push the widgets with agentlife_push, then respond "Done".
-
-Do NOT call agentlife.createAgent. Do NOT write workspace files. Do NOT spawn sub-sessions. Do NOT ask interactive questions. The user is not present — this runs at install time. Just read, build, push.
-
-## Handling Vision Dismiss
-
-When you receive \`[system:dismiss-requested] surfaceId=vision-{slug}\` — this is vision-specific dismiss handling. It is a third mode, distinct from agent creation and from dashboard bootstrap, and it OVERRIDES the general dismiss-alt protocol described elsewhere.
-
-**CRITICAL — session scope:** this section applies ONLY on your DIRECT session (where the user is live and can see widgets). The platform also notifies your INTERNAL session with the same \`[system:dismiss-requested]\` message as a cleanup hook AFTER the widget is already deleted. If you see this message on an internal session, do NOT push a dismiss-alt, do NOT run the steps below — the widget is gone and pushing a questionnaire creates a ghost surface that nobody can interact with. On internal sessions, output "done" and stop.
-
-Direct session vs internal session: internal sessions receive the "Internal Session — Self-Improvement Protocol" preamble at the top of their system prompt. If you see that preamble in your context, you are on an internal session; this Vision Dismiss section does NOT apply to you, output "done".
-
-The general dismiss-alt rule says "craft 2-3 contextual alternatives from the widget's goal." For vision posters that rule does NOT apply. Vision posters are aspirational content with a closed ontology of failure modes — the user is rejecting either the dream itself, its framing, its timing, or its dashboard placement. Improvising alternatives per dismiss would produce inconsistent wording across dismissals, which reads as broken UX. Use the fixed wording below verbatim.
-
-### Step 1 — Push the dismiss-alt input surface
-
-Push exactly this surface (substitute \`{slug}\` with the dismissed vision's slug). Wording is fixed: do not paraphrase, translate, or reorder the buttons. The user's language detection happens at synthesis time, not at dismiss time.
-
-\`\`\`
-surface dismiss-alt-vision-{slug} input
-  card
-    column
-      text "Before I remove this:" h4
-      button "This isn't my dream anymore" action=choice
-      button "Wrong framing" action=choice
-      button "Already achieved" action=choice
-      button "Don't show on dashboard" action=choice
-      button "Remove it" action=choice
-goal: Capture vision dismiss reason for vision-{slug}
-followup: +1m "User did not respond to vision dismiss alternatives. Say done."
-\`\`\`
-
-### Step 2 — On the user's choice, persist the reason
-
-When you receive \`[action:choice]\` on the dismiss-alt-vision-{slug} surface, append one line to your own workspace file at \`~/.openclaw/workspace-agentlife-builder/memory/vision-feedback.md\` (create the file and parent directory if missing):
-
-\`\`\`
-- {ISO timestamp} vision-{slug}: {chosen reason verbatim}
-\`\`\`
-
-Use exec for the append: \`mkdir -p ~/.openclaw/workspace-agentlife-builder/memory && echo "..." >> ~/.openclaw/workspace-agentlife-builder/memory/vision-feedback.md\`. This file is read by the next dashboard bootstrap as negative constraints under "## Previously rejected dreams" — your own future self will use it.
-
-### Step 3 — Let the dismiss complete
-
-Do NOT push a confirmation widget. Do NOT push \`delete vision-{slug}\`. The widget disappearing is the confirmation. The platform completes the dismiss after you process the action; you only need to record the reason.
-
-If you receive \`[event:dismissed] surfaceId=vision-{slug}\` afterwards, the surface is already gone — respond "done" and stop.
-
-### What this is NOT
-
-- Not a domain widget dismiss (those use the general contextual dismiss-alt rules).
-- Not an opportunity to generate a replacement vision (the bootstrap path handles regeneration).
-- Not a place to ask follow-up questions or push additional surfaces beyond the fixed dismiss-alt above.
-
 ## Deleting an Agent
 
 1. agentlife.deleteAgent: {"id": "{agentId}"}
@@ -1339,16 +1338,16 @@ If you receive \`[event:dismissed] surfaceId=vision-{slug}\` afterwards, the sur
 
 When you receive \`[action:*]\` on a confirmation widget: the user wants to use the agent you just created. Delegate the request to the new agent via \`sessions_send\` with the original user intent from your context. Delete your confirmation widget — the new agent takes over.
 
-## Onboarding (Cold Start)
+## Platform-Dispatched Entry Points — \`[system:*]\` Messages
 
-When you receive \`[system:onboarding]\` — the user has no agents yet. This is a fresh install. Your job is to help them create their FIRST agent with minimal friction. One question, one agent, break the cold start.
+The plugin's cold-start state machine dispatches these messages to your direct session at phase transitions. Each entry point is **atomic**: one starting message, one completion criterion. None overlap, none override your normal creation/improvement flow.
 
-### Step 1 — Push a guided input surface
+### \`[system:onboarding]\`
 
-Push a single \`input\` surface with life-domain choices. One question, one tap. The user picks a domain; you create an agent for it.
+User just installed AgentLife with zero specialist agents. Push the life-domain input surface, then \`done\`. Do not create any agent yet.
 
 \`\`\`
-surface onboarding input
+surface onboarding-domain input
   card
     column
       text "What area of your life should your first agent focus on?" h4
@@ -1358,33 +1357,148 @@ surface onboarding input
       button "Finance & money" action=choice
       button "Something else" action=choice
 goal: User picks a life domain for their first agent
-followup: +5m "User did not respond to onboarding. Say done."
+followup: +30m "User did not respond to onboarding. Say done."
 \`\`\`
 
-Detect the user's language from the gateway context (session transcript, locale). If the user writes in Spanish, push the widget in Spanish. Match the user's language — do NOT default to English.
+Translate button labels into the user's locale if known. Do not vary the surfaceId \`onboarding-domain\` — the state machine observes it.
 
-### Step 2 — On the user's choice, create the agent
+**When \`[action:choice] surfaceId=onboarding-domain label=<domain>\` arrives next, execute the full creation flow. You MUST complete every step below. A "ready" confirmation widget pushed without the \`agentlife.createAgent\` RPC call is a critical platform violation — the user sees a green "Ready" badge for an agent that does not exist, and the state machine never advances out of AWAITING_AGENT.**
 
-When the user taps a choice, follow your standard agent creation flow (Steps 1–6 above) but SKIP the interactive question phase — the user already told you the domain. Go straight to:
+Required call sequence for the post-choice creation turn:
 
-1. Environment discovery (exec checks relevant to the domain)
-2. Create workspace + all files (AGENTS.md, SOUL.md, IDENTITY.md, USER.md, HEARTBEAT.md)
-3. Register via agentlife.createAgent
-4. Push the confirmation widget
-5. Delete the onboarding input surface
+1. **Delete the input surface.** Push \`delete onboarding-domain\` (or \`delete health-qN\` if you asked follow-ups).
+2. **Clarifying questions (optional, 1-2 max).** If domain framing is ambiguous, push \`warmup-{slug}\` input surfaces to narrow scope. Skip this step if the label is already specific enough to create from.
+3. **Discover environment.** If the domain requires system facts (networks, devices, installed tools), run \`exec\` commands per Step 2 of the main "Creating a New Agent" flow above. Skip if the domain is purely behavioral (health, finance).
+4. **Write workspace files.** \`exec mkdir -p ~/.openclaw/workspace-{agentId}\` then \`write\` AGENTS.md, SOUL.md, IDENTITY.md, USER.md, HEARTBEAT.md. Follow Step 3 of the main creation flow — every file present, no placeholders.
+5. **Register the agent via \`exec\`.** Call \`exec openclaw gateway call agentlife.createAgent --params '<JSON>'\`. The JSON must include \`id\`, \`name\`, \`workspace\` (absolute path), \`description\`, \`tools\`, \`identity\`. This call is what makes the agent real — no shortcut.
+6. **Only after createAgent returns ok**, push the confirmation widget per Step 6 of the main creation flow.
 
-If the user taps "Something else," push ONE follow-up textfield input asking them to describe the domain in a sentence. Then proceed with creation.
+Forbidden shortcuts:
+- Do NOT push a "Ready" / "Created" / "Setting up" style confirmation widget before steps 4 and 5 complete.
+- Do NOT emit \`done\` until the RPC call in step 5 succeeded (check the response, not just that the tool ran).
+- Do NOT write about the agent being ready in chat text — the confirmation is the widget, and only after step 5.
 
-### What this is NOT
-
-- Not a comprehensive onboarding wizard. One question. One agent. The user can create more later by chatting normally.
-- Not a place to explain what AgentLife is. The user installed the plugin — they know.
-- Not a place to push multiple widgets. One input, one confirmation, done.
+If the user picked "Something else", push a follow-up textfield input on the same \`onboarding-domain\` surfaceId to capture the freeform domain, then proceed through steps 1-6 once you have an answer.
 
 ## What You Are Not
 
 - Not an orchestrator — you don't route messages
 - Not a general assistant — only agent creation and improvement
+- Not the vision synthesizer — \`[system:dashboard-bootstrap]\`, \`[system:ask-dream]\`, and vision dismissals belong to \`agentlife-vision\`
+`;
+var VISION_AGENTS_MD = `# AgentLife Vision Synthesizer
+
+You turn the user's data into the aspirational backdrop of the dashboard. You do not create agents, route messages, or answer questions. The platform dispatches you only for the three entry points below.
+
+## Platform-Dispatched Entry Points — \`[system:*]\` Messages
+
+These are your ONLY valid triggers. Each is atomic: one starting message, one completion criterion.
+
+### \`[system:dashboard-bootstrap]\`
+
+Synthesize vision posters from user data that the platform injects in the message body under \`## USER DATA\` (and optionally \`## userDream:\` when the user has answered the dream-ask flow). The task has **exactly two valid outcomes**:
+
+1. Push 1-4 \`vision-*\` posters quoted from USER DATA, then respond \`done\`.
+2. Respond \`NO_SIGNAL\` alone on its own line and STOP.
+
+Pushing a poster and then deleting it is NOT a valid recovery — the user sees the poster flash and disappear, which reads as a broken app. Pick ONE outcome.
+
+**Step 1 — Scan for aspirational signal.** In your own reasoning (not pushed), list the exact phrases where the user names a future they want, a target they're chasing, or a transformation they're working toward. Operational logging (times, weights, metrics, "no baseline yet") is NOT signal. Tone specs, tool schemas, and agent descriptions are NOT signal.
+
+**Step 2 — Decide.** If you listed at least one real quoted phrase → push posters. If you listed zero → respond \`NO_SIGNAL\` on its own line and STOP. Never invent a phrase the user didn't say. If you have to paraphrase or generalize to make it sound aspirational, it isn't signal — respond \`NO_SIGNAL\`.
+
+**Step 3 — Push posters (only if Step 2 said yes).** For each quoted phrase (max 4), push one vision poster. Each poster covers a DIFFERENT life area (body, money, place, work, relationships, identity, craft) and uses the user's actual words.
+
+A vision poster is the **aspirational backdrop** of the dashboard — it justifies the user's commitment to the platform and anchors why every other widget exists. Treat it like the cover of their year, not a sticker.
+
+#### Surface rules
+
+- \`size=l\` and \`priority=high\` — visions earn the largest slot and the highest sort order.
+- The face lives in \`card > column align=center\`. Top of the column is the emotional anchor; the bottom is the proof-of-progress.
+- Use the standard widget components (text, divider, badge, metric, progress, gauge, sparkline) — no exotic compositions. Pick the components that suit the dream's domain rather than copying a fixed shape.
+
+#### Face composition rules (apply to every vision poster)
+
+- Open with a single emoji at \`h1\` size — visceral, not literal. The emoji carries the emotional charge of the dream.
+- Follow with a declarative headline at \`h1\` in the accent color — 3-5 words, first-person when natural, naming the dream version (not the next checkpoint).
+- Add a support line in \`body\` text — 6-12 words drawn from the user's actual language. No generic platitudes.
+- Place a \`divider\` between the dream framing and the proof framing.
+- Below the divider include AT LEAST ONE quantitative element (\`progress\`, \`gauge\`, or two paired \`metric\`s) showing where the user stands today relative to the dream. If you have no real measurement, set the value to \`0.05\` and label it as the journey starting — never \`0.0\` (reads as broken), never invent a fake value.
+- End with one anchor element naming the time horizon, the place, the phase, or the milestone (a \`text\` line, a \`badge\`, or a \`row\` of accent-colored beats). Pick the anchor type that fits the dream's domain.
+- Vary the accent color across posters in the carousel. Suggested palette: \`#10B981\`, \`#7C3AED\`, \`#3B82F6\`, \`#F59E0B\`, \`#EC4899\`, \`#14B8A6\`.
+
+#### Metadata rules (every poster must carry all four)
+
+- \`goal:\` — ONE sentence in the user's voice naming the actual aspiration. References at least one concrete element from USER DATA (a quoted phrase, a number, a place, a domain term). Never write \`Vision poster — {slug}\` or any meta-label — that fails the platform's goal-validation rule (it could have been written before the work).
+- \`detail:\` — markdown body that earns the poster a place on the paywall. Required sections: a short "Why this matters" paragraph grounded in the user's data; a quote block with 1-2 verbatim phrases from USER DATA; a list of the 2-3 measurable signals (proxies) that would tell a specialist agent the user is on track, each tied to a real database table or habit; one named near-term milestone within the followup window.
+- \`followup:\` — duration scaled to the dream's natural rhythm: body/habit dreams 14-30d, money/career 30-90d, place/identity 90-180d. The instruction MUST name which proxies to query, the threshold separating "on track" from "drift", and the resulting action (push an update, reframe, or stay silent). \`Refresh this vision if data has shifted\` is forbidden — it could have been written before the work.
+- \`context:\` — JSON pointers the followup needs: domain tag, the user's quoted phrases that drove this poster, and \`{name, source}\` entries for each proxy so the next invocation knows where to read fresh data. Lookup keys only, no cached values.
+
+#### Universal rules
+
+- **Variety:** across the carousel, do not reuse the same anchor element type twice. If two posters end on a \`badge\`, rework one to use a \`row\` of beats or a \`text\` anchor. Composition variety is what stops the dashboard reading as a template grid.
+- **Goal & followup validation:** before pushing each poster, re-read its \`goal:\` and \`followup:\` lines and ask "could I have written these EXACT words before reading USER DATA?" If yes, rewrite — they're templates, not work product.
+- **Language consistency:** detect the primary language the user writes in from the data. Write ALL posters in that single language. Never mix languages across the carousel.
+- **Quality bar:** better to push 2 strong posters than 4 mixed-quality ones. If you cannot find a real, named, repeated dream for a domain, SKIP that domain. Never invent. Never fill a slot with weather data, agent infrastructure, or generic placeholder language. If a poster names tools/agents instead of outcomes, it is wrong — drop it.
+
+After all pushes, respond \`done\` and STOP. If you cannot find signal, respond \`NO_SIGNAL\` alone on its own line and STOP.
+
+### \`[system:ask-dream]\`
+
+The bootstrap reported \`NO_SIGNAL\`. Push the dream-capture input surface and \`done\`. Do NOT push posters from this entry — the plugin re-fires \`[system:dashboard-bootstrap]\` with \`userDream:\` injected after the user answers.
+
+\`\`\`
+surface awaiting-dream-input input
+  card
+    column
+      text "Tell me one dream or goal you want to track" h4
+      button "Body & health" action=choice
+      button "Money & work" action=choice
+      button "Place & life chapter" action=choice
+      button "Craft or identity" action=choice
+goal: Capture the user's dream so the dashboard can synthesize a vision poster
+followup: +30m "User did not respond to dream-ask. Say done."
+\`\`\`
+
+Translate labels into the user's locale if known. Do not vary the surfaceId \`awaiting-dream-input\` — the state machine observes it.
+
+### \`[system:dismiss-requested] surfaceId=vision-*\`
+
+User dismissed a vision poster. Push the fixed dismiss-alt surface below. Wording is fixed: do not paraphrase, translate, or reorder buttons.
+
+\`\`\`
+surface dismiss-alt-vision-{slug} input
+  card
+    column
+      text "Before I remove this:" h4
+      button "This isn't my dream anymore" action=choice
+      button "Wrong framing" action=choice
+      button "Already achieved" action=choice
+      button "Don't show on dashboard" action=choice
+      button "Remove it" action=choice
+goal: Capture vision dismiss reason for vision-{slug}
+followup: +1m "User did not respond to vision dismiss alternatives. Say done."
+\`\`\`
+
+After pushing, respond \`done\`.
+
+When \`[action:choice]\` arrives on \`dismiss-alt-vision-{slug}\`, append one line to your feedback memory via exec, then \`done\`:
+
+\`\`\`
+exec mkdir -p ~/.openclaw/workspace-agentlife-vision/memory && \\
+     echo "- $(date -u +%Y-%m-%dT%H:%M:%SZ) vision-{slug}: {reason}" \\
+        >> ~/.openclaw/workspace-agentlife-vision/memory/vision-feedback.md
+\`\`\`
+
+This file is injected as "Previously rejected dreams" into the next \`[system:dashboard-bootstrap]\` so future synthesis avoids the same misreads.
+
+Do NOT push a confirmation widget. Do NOT push \`delete vision-{slug}\` — the platform handles removal (soft-delete for paywall persistence; the widget disappears from the dashboard). If you receive \`[event:dismissed] surfaceId=vision-{slug}\` afterwards, the surface state has already been finalized — respond \`done\`.
+
+## What You Are Not
+
+- Not a builder — agent creation and improvement belong to \`agentlife-builder\`
+- Not an orchestrator — you never route or answer user questions
+- Not a chat agent — you produce widgets or \`NO_SIGNAL\`/\`done\` markers only
 `;
 var SUPERVISOR_AGENTS_MD = `# Dashboard Supervisor
 
@@ -1488,6 +1602,12 @@ var PROVISIONED_AGENTS = [
     agentsMd: BUILDER_AGENTS_MD,
     tools: { profile: "full", alsoAllow: ["agentlife_push"] }
   },
+  {
+    id: "agentlife-vision",
+    name: "AgentLife Vision",
+    agentsMd: VISION_AGENTS_MD,
+    tools: { profile: "full", alsoAllow: ["agentlife_push"] }
+  },
   {
     id: "supervisor",
     name: "Supervisor",
@@ -1604,216 +1724,6 @@ ${capped}`);
 
 `) };
 }
-var VISION_MIN_MEMORY_CHARS = 200;
-var BOOTSTRAP_COOLDOWN_MS = 10 * 60 * 1000;
-var lastBootstrapSentAt = 0;
-var lastWarmupSentAt = 0;
-function resetBootstrapCooldown() {
-  lastBootstrapSentAt = 0;
-  lastWarmupSentAt = 0;
-}
-async function ensureVisionPosters(state, runtime, log, options = {}) {
-  if (!state.surfaceDb) {
-    log("[agentlife] ensureVisionPosters: skipped — surfaceDb not initialized");
-    return { status: "skipped", reason: "no_surface_db" };
-  }
-  let visionCount = 0;
-  for (const surfaceId of state.surfaceDb.keys()) {
-    if (surfaceId.startsWith("vision-"))
-      visionCount++;
-  }
-  if (visionCount > 0) {
-    log(`[agentlife] ensureVisionPosters: already_exists — ${visionCount} vision surface(s) in surfaceDb`);
-    return { status: "already_exists", count: visionCount };
-  }
-  const SKIP_IDS = new Set(PROVISIONED_AGENTS.filter((a) => !a.existingAgent).map((a) => a.id));
-  const finalList = runtime.config.loadConfig().agents?.list ?? [];
-  const specialistCount = [...state.agentRegistry.keys()].filter((id) => !SKIP_IDS.has(id)).length;
-  if (specialistCount === 0) {
-    log("[agentlife] ensureVisionPosters: skipped — specialistCount=0 (no user agents registered)");
-    return { status: "skipped", reason: "no_specialists" };
-  }
-  if (!state.runCommand) {
-    log("[agentlife] ensureVisionPosters: skipped — runCommand not available on runtime");
-    return { status: "skipped", reason: "no_run_command" };
-  }
-  const { totalChars, sections } = await gatherAllAgentMemory(state, finalList, SKIP_IDS);
-  if (totalChars < VISION_MIN_MEMORY_CHARS) {
-    const warmupNow = Date.now();
-    if (state.runCommand && warmupNow - lastWarmupSentAt >= BOOTSTRAP_COOLDOWN_MS) {
-      const specialistId = [...state.agentRegistry.keys()].find((id) => !SKIP_IDS.has(id));
-      if (specialistId) {
-        lastWarmupSentAt = warmupNow;
-        const warmupKey = buildAgentSessionKey(specialistId);
-        const warmupMsg = [
-          `[system:warmup] You were just created and have no user data yet.`,
-          ``,
-          `1. Push a guided input widget (input surface, action=choice buttons) asking the user for the most important baseline info for your domain. One question at a time, 2-3 questions max.`,
-          `2. After each answer, WRITE the data to your memory directory: exec mkdir -p ~/.openclaw/workspace-${specialistId}/memory && write the answer to a file there (e.g., memory/baseline.md). This is critical — your memory directory is what the platform reads to generate the user's vision dashboard. If you only store data in widget context, it's lost when the widget is dismissed.`,
-          `3. After collecting all answers, push a DASHBOARD widget (NOT input) summarizing what you learned. This widget must NOT have the "input" keyword — it renders on the main dashboard, not the input bar.`,
-          `4. Use the user's language.`,
-          ``,
-          `If you already collected baseline data in a previous session, check your memory directory. If it has content, push a dashboard summary widget and respond "done". Do NOT re-ask questions you already have answers for.`
-        ].join(`
-`);
-        const warmupParams = JSON.stringify({
-          sessionKey: warmupKey,
-          message: warmupMsg,
-          idempotencyKey: `warmup-${specialistId}-${Date.now()}`
-        });
-        state.runCommand(["openclaw", "gateway", "call", "chat.send", "--params", warmupParams], { timeoutMs: 120000 }).then(() => {
-          log(`[agentlife] ensureVisionPosters: warmup sent to ${specialistId}`);
-        }).catch((e) => {
-          log(`[agentlife] ensureVisionPosters: warmup failed for ${specialistId}: ${e?.message}`);
-        });
-      }
-    }
-    log(`[agentlife] ensureVisionPosters: skipped — totalChars=${totalChars} below threshold ${VISION_MIN_MEMORY_CHARS} (memory too thin)`);
-    return { status: "skipped", reason: "thin_memory", details: `totalChars=${totalChars}` };
-  }
-  const homeDir = options.homedirOverride ?? os.homedir();
-  const builderWorkspace = path3.join(homeDir, ".openclaw", "workspace-agentlife-builder");
-  const feedbackFile = path3.join(builderWorkspace, "memory", "vision-feedback.md");
-  let rejectedDreams = "";
-  try {
-    const content = await fs2.readFile(feedbackFile, "utf-8");
-    if (content.trim())
-      rejectedDreams = content.trim().slice(0, 4000);
-  } catch {}
-  const now = Date.now();
-  if (now - lastBootstrapSentAt < BOOTSTRAP_COOLDOWN_MS) {
-    log(`[agentlife] ensureVisionPosters: skipped — bootstrap cooldown (${Math.round((BOOTSTRAP_COOLDOWN_MS - (now - lastBootstrapSentAt)) / 1000)}s remaining)`);
-    return { status: "skipped", reason: "cooldown", details: `${Math.round((BOOTSTRAP_COOLDOWN_MS - (now - lastBootstrapSentAt)) / 1000)}s remaining` };
-  }
-  const builderKey = buildAgentSessionKey("agentlife-builder");
-  const bootstrapMsg = [
-    `[system:dashboard-bootstrap] The dashboard is empty. Push 3-4 vision posters with agentlife_push.`,
-    ``,
-    `## What you do`,
-    ``,
-    `Pick 2 to 4 dreams from the user data below — quality over quantity. For each, copy one of the 3 DSL templates exactly and replace the placeholders with the user's own words. Push via agentlife_push.`,
-    ``,
-    `## Picking the dreams`,
-    ``,
-    `Find aspirational signal — moments where the user names a future they want, a target they're chasing, a transformation they're working toward. Operational logging is not signal.`,
-    ``,
-    `Each poster covers a DIFFERENT life area. Body, money, place, work, relationships, identity, craft are distinct. If two candidates share a product, person, or domain name, they're the same area — pick one.`,
-    ``,
-    `Pick the dream version of each goal — the one-to-three-year outcome if everything goes right, not the next checkpoint. The first real revenue is a checkpoint; the first profitable year is a dream.`,
-    ``,
-    `## Quality bar`,
-    ``,
-    `It is better to push 2 strong posters than 4 mixed-quality ones. If you cannot find a real, named, repeated dream for a domain, SKIP that domain. Never invent. Never fill a slot with weather data, agent infrastructure, or generic placeholder language. If a poster's content names tools/agents instead of outcomes, it is wrong — drop it.`,
-    ``,
-    `## Language consistency`,
-    ``,
-    `Detect the primary language the user writes in (look at the data: Spanish, English, etc.). Write ALL posters in that single language. Never mix languages across the carousel.`,
-    ``,
-    `## The 3 templates`,
-    ``,
-    `Every template renders emoji + headline + support + a bottom element. The bottom element changes per template.`,
-    ``,
-    `### TEMPLATE A — Statement (best for identity, body, declarative truths)`,
-    ``,
-    `surface vision-{slug} size=l`,
-    `  card`,
-    `    column align=center`,
-    `      text "{EMOJI}" h1`,
-    `      text "{HEADLINE}" h1 color={ACCENT}`,
-    `      text "{SUPPORT}" body`,
-    `      text "{MOMENT}" h4 color={ACCENT}`,
-    `goal: Vision poster — {slug}`,
-    `followup: +30d "Refresh this vision poster if the user's data has shifted."`,
-    ``,
-    `### TEMPLATE B — Destination (best for place, move, new chapter)`,
-    ``,
-    `surface vision-{slug} size=l`,
-    `  card`,
-    `    column align=center`,
-    `      text "{EMOJI}" h1`,
-    `      text "{HEADLINE}" h1 color={ACCENT}`,
-    `      text "{SUPPORT}" body`,
-    `      badge "{PLACE}" color={ACCENT} outlined`,
-    `goal: Vision poster — {slug}`,
-    `followup: +30d "Refresh this vision poster if the user's data has shifted."`,
-    ``,
-    `### TEMPLATE C — Outcome (best for work, money, craft)`,
-    ``,
-    `surface vision-{slug} size=l`,
-    `  card`,
-    `    column align=center`,
-    `      text "{EMOJI}" h1`,
-    `      text "{HEADLINE}" h1 color={ACCENT}`,
-    `      text "{SUPPORT}" body`,
-    `      row distribute=spaceEvenly`,
-    `        text "{C1}" h4 color={ACCENT}`,
-    `        text "·" h4`,
-    `        text "{C2}" h4 color={ACCENT}`,
-    `        text "·" h4`,
-    `        text "{C3}" h4 color={ACCENT}`,
-    `goal: Vision poster — {slug}`,
-    `followup: +30d "Refresh this vision poster if the user's data has shifted."`,
-    ``,
-    `## Placeholder rules`,
-    ``,
-    `- {slug}: short kebab-case slug for the life area`,
-    `- {ACCENT}: hex color. Vary across posters: try #10B981, #7C3AED, #3B82F6, #F59E0B, #EC4899, #14B8A6`,
-    `- {EMOJI}: a single emoji capturing the emotional core. Visceral, not literal.`,
-    `- {HEADLINE}: 3-5 words, declarative, first-person if natural, periods welcome. The dream version, not the next checkpoint.`,
-    `- {SUPPORT}: 6-12 words, one short sentence. Concrete supporting context in the user's actual language.`,
-    `- {MOMENT} (Template A): 1-3 words, a time anchor — season, year, phase`,
-    `- {PLACE} (Template B): 1-3 words, must be a real geographic place name (not a date)`,
-    `- {C1}, {C2}, {C3} (Template C): 1-2 words each, concept beats from the user's vocabulary`,
-    ``,
-    `## Variety rule`,
-    ``,
-    `Across the 3-4 posters, use AT LEAST 2 different templates.`,
-    ``,
-    `## Hard constraints`,
-    ``,
-    `- Copy ONE of the 3 templates above exactly. Do not add components. Do not remove components. Do not change order.`,
-    `- Use the user's actual language from the data — never invent.`,
-    ``,
-    ...rejectedDreams ? [
-      `## Previously rejected dreams`,
-      ``,
-      `The user has dismissed these past vision posters with the following reasons. Do NOT re-pick these dreams or reframe them with the same emphasis — the user already told you they were wrong.`,
-      ``,
-      rejectedDreams,
-      ``
-    ] : [],
-    `## USER DATA`,
-    ``,
-    sections.slice(0, 12000),
-    ``,
-    `## Output`,
-    ``,
-    `Push each poster with agentlife_push. After the last push, respond "Done".`
-  ].join(`
-`);
-  const params = JSON.stringify({
-    sessionKey: builderKey,
-    message: bootstrapMsg,
-    idempotencyKey: `dashboard-bootstrap-${Date.now()}`
-  });
-  lastBootstrapSentAt = Date.now();
-  const delayMs = options.delayMs ?? 0;
-  const feedbackChars = rejectedDreams.length;
-  const runBootstrap = () => {
-    log(`[agentlife] ensureVisionPosters: synthesizing (${totalChars} chars memory across ${specialistCount} specialists${feedbackChars > 0 ? `, ${feedbackChars} chars prior feedback` : ""})`);
-    state.runCommand(["openclaw", "gateway", "call", "chat.send", "--params", params], { timeoutMs: 300000 }).then(() => {
-      log("[agentlife] ensureVisionPosters: dashboard bootstrap complete");
-    }).catch((e) => {
-      log(`[agentlife] ensureVisionPosters: dashboard bootstrap failed: ${e?.message}`);
-    });
-  };
-  if (delayMs > 0) {
-    setTimeout(runBootstrap, delayMs);
-  } else {
-    runBootstrap();
-  }
-  return { status: "synthesizing", specialistCount, totalChars, feedbackChars };
-}
 async function provisionAgents(state, cfg, runtime, log) {
   const home = os.homedir();
   const currentList = [...cfg.agents?.list ?? []];
@@ -1880,10 +1790,12 @@ async function provisionAgents(state, cfg, runtime, log) {
       log(`[agentlife] backfilled subagents for ${agent.id}`);
     }
   }
-  const rawCfgForVisibility = JSON.parse(readFileSync(path3.join(os.homedir(), ".openclaw", "openclaw.json"), "utf-8"));
+  const configPath = path3.join(os.homedir(), ".openclaw", "openclaw.json");
+  const rawCfgForVisibility = JSON.parse(readFileSync(configPath, "utf-8"));
+  const backupPath = path3.join(os.homedir(), ".openclaw", "agentlife", "config-backup.json");
+  let visibilityWritten = false;
   const currentVisibility = rawCfgForVisibility?.tools?.sessions?.visibility;
   if (currentVisibility !== "all") {
-    const backupPath = path3.join(os.homedir(), ".openclaw", "agentlife", "config-backup.json");
     try {
       let backup = {};
       try {
@@ -1898,14 +1810,40 @@ async function provisionAgents(state, cfg, runtime, log) {
     if (!rawCfgForVisibility.tools.sessions)
       rawCfgForVisibility.tools.sessions = {};
     rawCfgForVisibility.tools.sessions.visibility = "all";
-    writeFileSync(path3.join(os.homedir(), ".openclaw", "openclaw.json"), JSON.stringify(rawCfgForVisibility, null, 2) + `
+    visibilityWritten = true;
+  }
+  const currentAllow = rawCfgForVisibility?.tools?.allow;
+  let globalAllowWritten = false;
+  if (Array.isArray(currentAllow) && currentAllow.length > 0 && !currentAllow.includes("*")) {
+    const onlyPluginTool = currentAllow.length === 1 && currentAllow[0] === "agentlife_push";
+    if (onlyPluginTool) {
+      try {
+        let backup = {};
+        try {
+          backup = JSON.parse(readFileSync(backupPath, "utf-8"));
+        } catch {}
+        if (backup.toolsAllow === undefined) {
+          backup.toolsAllow = [...currentAllow];
+          writeFileSync(backupPath, JSON.stringify(backup, null, 2) + `
+`, "utf-8");
+        }
+      } catch {}
+      rawCfgForVisibility.tools.allow = ["*", "agentlife_push"];
+      globalAllowWritten = true;
+    }
+  }
+  if (visibilityWritten || globalAllowWritten) {
+    writeFileSync(configPath, JSON.stringify(rawCfgForVisibility, null, 2) + `
 `, "utf-8");
     configChanged = true;
-    log("[agentlife] set tools.sessions.visibility=all (cross-agent delegation)");
+    if (visibilityWritten)
+      log("[agentlife] set tools.sessions.visibility=all (cross-agent delegation)");
+    if (globalAllowWritten)
+      log('[agentlife] added "*" to tools.allow (unblock exec/read/write for provisioned agents)');
   }
   if (configChanged) {
-    const configPath = path3.join(os.homedir(), ".openclaw", "openclaw.json");
-    const rawCfg = JSON.parse(readFileSync(configPath, "utf-8"));
+    const configPath2 = path3.join(os.homedir(), ".openclaw", "openclaw.json");
+    const rawCfg = JSON.parse(readFileSync(configPath2, "utf-8"));
     const updatedCfg = {
       ...rawCfg,
       agents: {
@@ -1913,7 +1851,7 @@ async function provisionAgents(state, cfg, runtime, log) {
         list: currentList
       }
     };
-    writeFileSync(configPath, JSON.stringify(updatedCfg, null, 2) + `
+    writeFileSync(configPath2, JSON.stringify(updatedCfg, null, 2) + `
 `, "utf-8");
     log("[agentlife] config updated with provisioned agents");
   }
@@ -1991,12 +1929,538 @@ async function provisionAgents(state, cfg, runtime, log) {
       }, 1e4);
     }
   }
-  await ensureVisionPosters(state, runtime, log, { delayMs: 15000 });
   log("[agentlife] agent provisioning complete");
 }
 
-// services/surfaces-init.ts
+// cold-start.ts
+import * as fs3 from "node:fs/promises";
+import * as nodeFs from "node:fs";
+import * as os2 from "node:os";
 import * as path4 from "node:path";
+var DEADLINE_MS = {
+  AWAITING_AGENT: 30 * 60 * 1000,
+  AWAITING_BASELINE: 30 * 60 * 1000,
+  SYNTHESIZING: 3 * 60 * 1000,
+  AWAITING_DREAM: 30 * 60 * 1000
+};
+var VISION_MIN_MEMORY_CHARS = 200;
+var PHASE_BLANK = "BLANK";
+function readState(state) {
+  const db = getOrCreateHistoryDb(state);
+  const row = db.prepare("SELECT * FROM cold_start_state WHERE id = 1").get();
+  if (!row)
+    return null;
+  let warnings = [];
+  if (row.contractWarnings) {
+    try {
+      warnings = JSON.parse(row.contractWarnings);
+    } catch {}
+  }
+  return {
+    phase: row.phase,
+    enteredAt: row.enteredAt,
+    lastActionAt: row.lastActionAt ?? null,
+    ackAt: row.ackAt ?? null,
+    deadlineAt: row.deadlineAt ?? null,
+    retryCount: row.retryCount ?? 0,
+    failureReason: row.failureReason ?? null,
+    lastTrigger: row.lastTrigger ?? null,
+    actionSessionKey: row.actionSessionKey ?? null,
+    contractWarnings: warnings,
+    pollerLastTickAt: row.pollerLastTickAt ?? null,
+    updatedAt: row.updatedAt
+  };
+}
+function ensureInitialRow(state) {
+  const existing = readState(state);
+  if (existing)
+    return existing;
+  const now = Date.now();
+  const db = getOrCreateHistoryDb(state);
+  db.prepare(`
+    INSERT OR IGNORE INTO cold_start_state
+      (id, phase, enteredAt, retryCount, contractWarnings, updatedAt)
+    VALUES (1, ?, ?, 0, '[]', ?)
+  `).run(PHASE_BLANK, now, now);
+  return readState(state);
+}
+function writeState(state, partial) {
+  const current = ensureInitialRow(state);
+  const next = { ...current, ...partial, updatedAt: Date.now() };
+  const db = getOrCreateHistoryDb(state);
+  db.prepare(`
+    UPDATE cold_start_state SET
+      phase = ?,
+      enteredAt = ?,
+      lastActionAt = ?,
+      ackAt = ?,
+      deadlineAt = ?,
+      retryCount = ?,
+      failureReason = ?,
+      lastTrigger = ?,
+      actionSessionKey = ?,
+      contractWarnings = ?,
+      pollerLastTickAt = ?,
+      updatedAt = ?
+    WHERE id = 1
+  `).run(next.phase, next.enteredAt, next.lastActionAt, next.ackAt, next.deadlineAt, next.retryCount, next.failureReason, next.lastTrigger, next.actionSessionKey, JSON.stringify(next.contractWarnings ?? []), next.pollerLastTickAt, next.updatedAt);
+  return next;
+}
+function emitTrigger(state, kind, payload) {
+  if (state.disabled)
+    return;
+  try {
+    const db = getOrCreateHistoryDb(state);
+    db.prepare(`
+      INSERT INTO cold_start_triggers (kind, payload, createdAt) VALUES (?, ?, ?)
+    `).run(kind, JSON.stringify(payload), Date.now());
+  } catch (e) {
+    console.warn("[cold-start] emitTrigger failed:", e?.message);
+  }
+}
+function drainTriggers(state, limit = 50) {
+  const db = getOrCreateHistoryDb(state);
+  const rows = db.prepare("SELECT id, kind, payload FROM cold_start_triggers ORDER BY createdAt ASC LIMIT ?").all(limit);
+  if (rows.length === 0)
+    return [];
+  const ids = rows.map((r) => r.id);
+  const placeholders = ids.map(() => "?").join(",");
+  db.prepare(`DELETE FROM cold_start_triggers WHERE id IN (${placeholders})`).run(...ids);
+  return rows.map((r) => ({
+    kind: r.kind,
+    payload: safeJson(r.payload)
+  }));
+}
+function safeJson(s) {
+  try {
+    return JSON.parse(s);
+  } catch {
+    return {};
+  }
+}
+function purgeStaleTriggers(state) {
+  const db = getOrCreateHistoryDb(state);
+  const cutoff = Date.now() - 60 * 60 * 1000;
+  const r = db.prepare("DELETE FROM cold_start_triggers WHERE createdAt < ?").run(cutoff);
+  return r.changes;
+}
+function pendingTriggerCount(state) {
+  const db = getOrCreateHistoryDb(state);
+  const row = db.prepare("SELECT COUNT(*) as c FROM cold_start_triggers").get();
+  return row?.c ?? 0;
+}
+var PROVISIONED_IDS = new Set(PROVISIONED_AGENTS.filter((a) => !a.existingAgent).map((a) => a.id));
+function listSpecialistIds(state, runtime) {
+  const cfg = runtime.config.loadConfig();
+  const list = cfg?.agents?.list ?? [];
+  return list.map((a) => a?.id).filter((id) => !!id && !PROVISIONED_IDS.has(id));
+}
+async function specialistMemoryTotal(state, runtime) {
+  const cfg = runtime.config.loadConfig();
+  const list = cfg?.agents?.list ?? [];
+  const { totalChars, sections } = await gatherAllAgentMemory(state, list, PROVISIONED_IDS);
+  return { total: totalChars, sections };
+}
+function visionSurfaceCount(state) {
+  if (!state.surfaceDb)
+    return 0;
+  let n = 0;
+  for (const id of state.surfaceDb.keys())
+    if (id.startsWith("vision-"))
+      n++;
+  return n;
+}
+async function sendSystemMessage(state, agentId, message, idempotencyKey, log) {
+  if (!state.runCommand) {
+    log(`[cold-start] sendSystemMessage ${idempotencyKey}: skipped — runCommand not available`);
+    return null;
+  }
+  const sessionKey = buildAgentSessionKey(agentId);
+  const chatParams = JSON.stringify({ sessionKey, message, idempotencyKey });
+  state.runCommand(["openclaw", "gateway", "call", "chat.send", "--params", chatParams], { timeoutMs: 120000 }).then(() => {
+    log(`[cold-start] sent ${idempotencyKey} → ${sessionKey}`);
+  }).catch((e) => {
+    log(`[cold-start] sendSystemMessage ${idempotencyKey} failed: ${e?.message}`);
+  });
+  return sessionKey;
+}
+async function composeBootstrapMessage(state, runtime, userDream) {
+  const { sections } = await specialistMemoryTotal(state, runtime);
+  const rejected = await readRejectedDreams();
+  const parts = ["[system:dashboard-bootstrap]", "", "## USER DATA", "", sections.slice(0, 12000)];
+  if (rejected)
+    parts.push("", "## Previously rejected dreams", "", rejected);
+  if (userDream)
+    parts.push("", "## userDream", "", userDream);
+  return parts.join(`
+`);
+}
+async function readRejectedDreams() {
+  const visionWorkspace = path4.join(os2.homedir(), ".openclaw", "workspace-agentlife-vision");
+  const feedbackFile = path4.join(visionWorkspace, "memory", "vision-feedback.md");
+  try {
+    const content = await fs3.readFile(feedbackFile, "utf-8");
+    return content.trim().slice(0, 4000);
+  } catch {
+    return "";
+  }
+}
+async function computeStartingPhase(state, runtime) {
+  if (visionSurfaceCount(state) > 0) {
+    return { phase: "READY", details: "vision surfaces already exist" };
+  }
+  const specialists = listSpecialistIds(state, runtime);
+  if (specialists.length === 0) {
+    return { phase: "BLANK", details: "no specialists" };
+  }
+  const { total } = await specialistMemoryTotal(state, runtime);
+  if (total < VISION_MIN_MEMORY_CHARS) {
+    return { phase: "AWAITING_BASELINE", details: `totalChars=${total} below ${VISION_MIN_MEMORY_CHARS}` };
+  }
+  return { phase: "SYNTHESIZING", details: `totalChars=${total} ready for synthesis` };
+}
+async function transition(state, runtime, log, trigger) {
+  const cur = ensureInitialRow(state);
+  log(`[cold-start] trigger=${trigger.kind} phase=${cur.phase}`);
+  switch (trigger.kind) {
+    case "provisioned":
+    case "userRetried": {
+      const { phase, details } = await computeStartingPhase(state, runtime);
+      log(`[cold-start] recompute → ${phase} (${details})`);
+      return enterPhase(state, runtime, log, phase, {
+        bumpRetry: trigger.kind === "userRetried"
+      });
+    }
+    case "agentRegistered": {
+      if (cur.phase === "BLANK" || cur.phase === "AWAITING_AGENT") {
+        return enterPhase(state, runtime, log, "AWAITING_BASELINE", {
+          specialistId: trigger.payload.agentId
+        });
+      }
+      return cur;
+    }
+    case "agentDeleted": {
+      const remaining = trigger.payload.remaining;
+      if (remaining === 0) {
+        return enterPhase(state, runtime, log, "BLANK");
+      }
+      return cur;
+    }
+    case "memoryWritten": {
+      if (cur.phase !== "AWAITING_BASELINE")
+        return cur;
+      const { total } = await specialistMemoryTotal(state, runtime);
+      if (total >= VISION_MIN_MEMORY_CHARS) {
+        return enterPhase(state, runtime, log, "SYNTHESIZING");
+      }
+      log(`[cold-start] memory still thin: ${total}/${VISION_MIN_MEMORY_CHARS}`);
+      return cur;
+    }
+    case "surfacePushed": {
+      return cur;
+    }
+    case "agentReplied": {
+      const sessionKey = trigger.payload.sessionKey;
+      const marker = trigger.payload.marker;
+      const lastText = trigger.payload.lastText ?? "";
+      if (cur.actionSessionKey && sessionKey && sessionKey !== cur.actionSessionKey) {
+        return cur;
+      }
+      if (cur.phase === "SYNTHESIZING") {
+        if (marker === "NO_SIGNAL" || /\bNO_SIGNAL\b/.test(lastText)) {
+          return enterPhase(state, runtime, log, "AWAITING_DREAM");
+        }
+        if (visionSurfaceCount(state) >= 1) {
+          return enterPhase(state, runtime, log, "READY");
+        }
+        return cur;
+      }
+      if (cur.phase === "AWAITING_BASELINE") {
+        return cur;
+      }
+      return cur;
+    }
+    case "userAnswered": {
+      const surfaceId = trigger.payload.surfaceId;
+      const answer = trigger.payload.answer ?? "";
+      if (cur.phase === "AWAITING_DREAM" && surfaceId === "awaiting-dream-input") {
+        return enterPhase(state, runtime, log, "SYNTHESIZING", { userDream: answer });
+      }
+      return cur;
+    }
+    case "deadlineElapsed": {
+      const elapsedPhase = trigger.payload.phase;
+      if (elapsedPhase !== cur.phase)
+        return cur;
+      const reason = `${cur.phase.toLowerCase()}_timeout`;
+      return enterFailed(state, log, reason);
+    }
+  }
+}
+async function enterPhase(state, runtime, log, next, opts = {}) {
+  const cur = ensureInitialRow(state);
+  const now = Date.now();
+  const deadlineMs = DEADLINE_MS[next];
+  const deadlineAt = deadlineMs ? now + deadlineMs : null;
+  const retryCount = opts.bumpRetry ? cur.retryCount + 1 : cur.retryCount;
+  let actionSessionKey = null;
+  let lastActionAt = null;
+  writeState(state, {
+    phase: next,
+    enteredAt: now,
+    deadlineAt,
+    retryCount,
+    failureReason: next === "FAILED" ? cur.failureReason : null,
+    actionSessionKey: null,
+    lastActionAt: null,
+    ackAt: null
+  });
+  log(`[cold-start] enter ${next} (deadline=${deadlineAt ? new Date(deadlineAt).toISOString() : "none"}, retry=${retryCount})`);
+  if (next === "BLANK") {
+    const idem = `cold-start-onboarding-${now}-${retryCount}`;
+    const msg = [
+      "[system:onboarding]",
+      "",
+      "User just installed AgentLife and has zero specialist agents. Push the",
+      "onboarding-domain input surface EXACTLY as specified in the [system:onboarding]",
+      "section of your AGENTS.md, then respond `done`. Do NOT ask the user questions",
+      "as chat text — only via the input surface. Do NOT create any specialist agent",
+      "yet; wait for the user's choice on the surface."
+    ].join(`
+`);
+    actionSessionKey = await sendSystemMessage(state, "agentlife-builder", msg, idem, log);
+    lastActionAt = Date.now();
+    writeState(state, {
+      phase: "AWAITING_AGENT",
+      enteredAt: now,
+      deadlineAt: now + (DEADLINE_MS.AWAITING_AGENT ?? 0),
+      actionSessionKey,
+      lastActionAt
+    });
+    scheduleDeadline(state, runtime, log, "AWAITING_AGENT", now + (DEADLINE_MS.AWAITING_AGENT ?? 0));
+    return readState(state);
+  }
+  if (next === "AWAITING_BASELINE") {
+    const specialistId = opts.specialistId ?? listSpecialistIds(state, runtime)[0];
+    if (!specialistId) {
+      log("[cold-start] AWAITING_BASELINE has no specialist to warm up — falling back to BLANK");
+      return enterPhase(state, runtime, log, "BLANK");
+    }
+    const idem = `cold-start-start-${specialistId}-${now}-${retryCount}`;
+    const msg = [
+      "[system:start]",
+      "",
+      "You were just created by the builder. You have zero memory about this user.",
+      "Follow the [system:start] section of your AGENTS.md: push a loading widget",
+      "introducing yourself per IDENTITY.md, then push ONE warmup-* input surface",
+      "asking the most important baseline question for your domain, then respond",
+      "`done`. Do NOT ask multiple questions in chat text — only via input surfaces."
+    ].join(`
+`);
+    actionSessionKey = await sendSystemMessage(state, specialistId, msg, idem, log);
+    lastActionAt = Date.now();
+  }
+  if (next === "SYNTHESIZING") {
+    const msg = await composeBootstrapMessage(state, runtime, opts.userDream);
+    const idem = `cold-start-bootstrap-${now}-${retryCount}`;
+    actionSessionKey = await sendSystemMessage(state, "agentlife-vision", msg, idem, log);
+    lastActionAt = Date.now();
+  }
+  if (next === "AWAITING_DREAM") {
+    const idem = `cold-start-ask-dream-${now}-${retryCount}`;
+    const msg = [
+      "[system:ask-dream]",
+      "",
+      "Bootstrap reported NO_SIGNAL — the user's data has no aspirational content yet.",
+      "Push the awaiting-dream-input input surface EXACTLY as specified in the",
+      "[system:ask-dream] section of your AGENTS.md, then respond `done`. Do NOT push",
+      "any vision posters from this turn — the plugin re-fires [system:dashboard-bootstrap]",
+      "with userDream: injected after the user answers."
+    ].join(`
+`);
+    actionSessionKey = await sendSystemMessage(state, "agentlife-vision", msg, idem, log);
+    lastActionAt = Date.now();
+  }
+  writeState(state, { actionSessionKey, lastActionAt });
+  if (deadlineAt)
+    scheduleDeadline(state, runtime, log, next, deadlineAt);
+  return readState(state);
+}
+function enterFailed(state, log, reason) {
+  log(`[cold-start] FAILED: ${reason}`);
+  return writeState(state, {
+    phase: "FAILED",
+    enteredAt: Date.now(),
+    failureReason: reason,
+    deadlineAt: null,
+    actionSessionKey: null
+  });
+}
+var deadlineTimers = new Map;
+function scheduleDeadline(state, runtime, log, phase, deadlineAt) {
+  const key = `${phase}-${deadlineAt}`;
+  for (const [k, t] of deadlineTimers.entries()) {
+    if (k.startsWith(`${phase}-`)) {
+      clearTimeout(t);
+      deadlineTimers.delete(k);
+    }
+  }
+  const remaining = Math.max(0, deadlineAt - Date.now());
+  const timer = setTimeout(() => {
+    deadlineTimers.delete(key);
+    emitTrigger(state, "deadlineElapsed", { phase });
+  }, remaining);
+  deadlineTimers.set(key, timer);
+  log(`[cold-start] scheduled ${phase} deadline in ${Math.round(remaining / 1000)}s`);
+}
+function rearmDeadlines(state, runtime, log) {
+  const cur = ensureInitialRow(state);
+  if (cur.deadlineAt && cur.phase !== "READY" && cur.phase !== "FAILED") {
+    if (cur.deadlineAt <= Date.now()) {
+      emitTrigger(state, "deadlineElapsed", { phase: cur.phase });
+    } else {
+      scheduleDeadline(state, runtime, log, cur.phase, cur.deadlineAt);
+    }
+  }
+}
+var pollerTimer = null;
+var POLLER_INTERVAL_MS = 1000;
+var POLLER_STUCK_THRESHOLD_MS = 30000;
+var machineRuntime = null;
+var machineLog = null;
+var machineState = null;
+function startPoller(state, runtime, log) {
+  if (pollerTimer)
+    return;
+  let lastDrainAt = Date.now();
+  let lastWarnedAt = 0;
+  pollerTimer = setInterval(async () => {
+    if (state.disabled)
+      return;
+    try {
+      const triggers = drainTriggers(state, 50);
+      const now = Date.now();
+      writeState(state, { pollerLastTickAt: now });
+      if (triggers.length > 0) {
+        lastDrainAt = now;
+        for (const trigger of triggers) {
+          try {
+            await transition(state, runtime, log, trigger);
+          } catch (e) {
+            log(`[cold-start] transition error for ${trigger.kind}: ${e?.message ?? e}`);
+          }
+        }
+        purgeStaleTriggers(state);
+      } else {
+        const pending = pendingTriggerCount(state);
+        if (pending > 0 && now - lastDrainAt > POLLER_STUCK_THRESHOLD_MS && now - lastWarnedAt > POLLER_STUCK_THRESHOLD_MS) {
+          log(`[cold-start] WARNING: poller has not drained ${pending} pending trigger(s) for ${Math.round((now - lastDrainAt) / 1000)}s`);
+          lastWarnedAt = now;
+        }
+      }
+    } catch (e) {
+      log(`[cold-start] poller tick error: ${e?.message ?? e}`);
+    }
+  }, POLLER_INTERVAL_MS);
+}
+function stopPoller() {
+  if (pollerTimer) {
+    clearInterval(pollerTimer);
+    pollerTimer = null;
+  }
+}
+function runRuntimeContractProbe(state, runtime, log) {
+  const PLUGIN_REGISTERED_TOOLS = ["agentlife_push"];
+  let list = [];
+  try {
+    const raw = nodeFs.readFileSync(path4.join(os2.homedir(), ".openclaw", "openclaw.json"), "utf-8");
+    const parsed = JSON.parse(raw);
+    list = parsed?.agents?.list ?? [];
+  } catch {
+    list = runtime.config.loadConfig()?.agents?.list ?? [];
+  }
+  const warnings = [];
+  for (const provisioned of PROVISIONED_AGENTS) {
+    if (provisioned.existingAgent)
+      continue;
+    const live = list.find((a) => a?.id === provisioned.id);
+    const liveTools = live?.tools ?? {};
+    const allow = Array.isArray(liveTools.allow) ? liveTools.allow : [];
+    const alsoAllow = Array.isArray(liveTools.alsoAllow) ? liveTools.alsoAllow : [];
+    const deny = Array.isArray(liveTools.deny) ? liveTools.deny : [];
+    for (const tool of PLUGIN_REGISTERED_TOOLS) {
+      const escaped = tool.replace(/[-/\\^$*+?.()|[\]{}]/g, "\\$&");
+      const re = new RegExp("`[^`]*\\b" + escaped + "\\b[^`]*`");
+      if (!re.test(provisioned.agentsMd))
+        continue;
+      const granted = (allow.includes(tool) || alsoAllow.includes(tool)) && !deny.includes(tool);
+      if (!granted) {
+        const w = `precondition_tool_missing:${provisioned.id}:${tool}`;
+        warnings.push(w);
+        log(`[cold-start] contract warning: ${w}`);
+      }
+    }
+  }
+  return warnings;
+}
+async function initColdStartMachine(state, runtime, log) {
+  machineState = state;
+  machineRuntime = runtime;
+  machineLog = log;
+  ensureInitialRow(state);
+  const warnings = runRuntimeContractProbe(state, runtime, log);
+  writeState(state, { contractWarnings: warnings });
+  rearmDeadlines(state, runtime, log);
+  startPoller(state, runtime, log);
+  const cur = readState(state);
+  if (cur.phase === "READY" && visionSurfaceCount(state) === 0) {
+    log("[cold-start] READY with 0 vision surfaces — demoting to FAILED(ready_no_surfaces) on init");
+    enterFailed(state, log, "ready_no_surfaces");
+    log("[cold-start] machine initialized");
+    return;
+  }
+  if (cur.phase !== "BLANK") {
+    log(`[cold-start] restart recovery — preserving persisted phase=${cur.phase} (no provisioned re-fire)`);
+    log("[cold-start] machine initialized");
+    return;
+  }
+  emitTrigger(state, "provisioned", { source: "init" });
+  log("[cold-start] machine initialized");
+}
+function shutdownColdStartMachine() {
+  stopPoller();
+  for (const t of deadlineTimers.values())
+    clearTimeout(t);
+  deadlineTimers.clear();
+}
+function observeColdStart(state) {
+  const s = ensureInitialRow(state);
+  return {
+    phase: s.phase,
+    failureReason: s.failureReason,
+    retryCount: s.retryCount,
+    contractWarnings: s.contractWarnings,
+    enteredAt: s.enteredAt,
+    deadlineAt: s.deadlineAt
+  };
+}
+async function retryColdStart(state) {
+  emitTrigger(state, "userRetried", { ts: Date.now() });
+  if (machineRuntime && machineLog) {
+    const triggers = drainTriggers(state, 50);
+    for (const trigger of triggers) {
+      try {
+        await transition(state, machineRuntime, machineLog, trigger);
+      } catch (e) {
+        machineLog(`[cold-start] retry-drain transition error for ${trigger.kind}: ${e?.message ?? e}`);
+      }
+    }
+  }
+  return observeColdStart(state);
+}
+
+// services/surfaces-init.ts
+import * as path5 from "node:path";
 
 // activity.ts
 function recordSurfaceEvent(state, surfaceId, event, dsl, agentId, metadata) {
@@ -2094,8 +2558,8 @@ function broadcastInput(message, sessionKey) {
 }
 
 // dashboard-state.ts
-import { readFileSync as readFileSync2 } from "node:fs";
-import { homedir as homedir2 } from "node:os";
+import { readFileSync as readFileSync3 } from "node:fs";
+import { homedir as homedir3 } from "node:os";
 function extractTitleAndDetail(meta) {
   let title = null;
   let detail = null;
@@ -2308,9 +2772,9 @@ ${enhanced.formatted}`;
               const agentFiles = [];
               for (const w of warnings) {
                 const aid = w.agentId;
-                const filePath = `${homedir2()}/.openclaw/workspace-${aid}/AGENTS.md`;
+                const filePath = `${homedir3()}/.openclaw/workspace-${aid}/AGENTS.md`;
                 try {
-                  const content = readFileSync2(filePath, "utf-8").slice(0, 3000);
+                  const content = readFileSync3(filePath, "utf-8").slice(0, 3000);
                   agentFiles.push(`### ${aid} AGENTS.md (${w.cnt} warnings)
 ${content}`);
                 } catch {}
@@ -2843,6 +3307,22 @@ function processDslBlock(state, dsl) {
       missingCardStructure: validation.missingCardStructure ? true : undefined
     });
     recordSurfaceEvent(state, sid, existing ? "updated" : "created", block, state.surfaceDb.getAgentId(sid));
+    if (!existing) {
+      let kind = null;
+      if (sid.startsWith("vision-"))
+        kind = "vision";
+      else if (sid === "awaiting-dream-input")
+        kind = "dream-input";
+      else if (sid === "onboarding-domain")
+        kind = "onboarding";
+      if (kind) {
+        try {
+          emitTrigger(state, "surfacePushed", { surfaceId: sid, kind, agentId: state.surfaceDb.getAgentId(sid) ?? null });
+        } catch (e) {
+          console.warn("[agentlife] cold-start emit surfacePushed failed: %s", e?.message);
+        }
+      }
+    }
   }
   return results;
 }
@@ -2986,23 +3466,27 @@ function registerSurfacesService(api, state) {
   api.registerService({
     id: "agentlife-surfaces",
     start: async (ctx) => {
-      const agentlifeDir = path4.join(ctx.stateDir, "agentlife");
+      const agentlifeDir = path5.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");
+      state.registryFilePath = path5.join(agentlifeDir, "agent-registry.json");
+      state.dbBaseDir = path5.join(agentlifeDir, "db");
+      state.historyDbPath = path5.join(agentlifeDir, "agentlife.db");
       if (!state.surfaceDb) {
         const db = getOrCreateHistoryDb(state);
         state.surfaceDb = new SurfaceDb(db);
       }
       runStartupPurge(state);
+      const FLOW_INPUT_IDS = new Set(["onboarding-domain", "awaiting-dream-input"]);
+      const isFlowInput = (id) => FLOW_INPUT_IDS.has(id) || id.startsWith("warmup-") || id.startsWith("dismiss-alt-");
       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 (!/\binput\b/.test(headerLine))
+          continue;
+        if (isFlowInput(surfaceId))
+          continue;
+        state.surfaceDb.delete(surfaceId);
+        inputPurged++;
       }
       if (inputPurged > 0) {
         console.log("[agentlife] purged %d stale input surfaces on startup", inputPurged);
@@ -3055,36 +3539,40 @@ function registerSurfacesService(api, state) {
 }
 
 // services/config-optimizer.ts
-import * as fs3 from "node:fs/promises";
-import * as path5 from "node:path";
-import * as os2 from "node:os";
+import * as fs4 from "node:fs/promises";
+import * as path6 from "node:path";
+import * as os3 from "node:os";
 var TARGET_MAX_PING_PONG = 1;
 var TARGET_MAX_CONCURRENT = 10;
-var CONFIG_PATH = path5.join(os2.homedir(), ".openclaw", "openclaw.json");
+var CONFIG_PATH = path6.join(os3.homedir(), ".openclaw", "openclaw.json");
 async function readRawConfigFromDisk() {
-  const raw = await fs3.readFile(CONFIG_PATH, "utf-8");
+  const raw = await fs4.readFile(CONFIG_PATH, "utf-8");
   return JSON.parse(raw);
 }
 async function writeRawConfigToDisk(cfg) {
-  await fs3.writeFile(CONFIG_PATH, JSON.stringify(cfg, null, 2) + `
+  await fs4.writeFile(CONFIG_PATH, JSON.stringify(cfg, null, 2) + `
 `, "utf-8");
 }
 async function restoreConfigFromBackup(api, backupPath) {
-  const raw = await fs3.readFile(backupPath, "utf-8");
+  const raw = await fs4.readFile(backupPath, "utf-8");
   const backup = JSON.parse(raw);
   const fileCfg = await readRawConfigFromDisk();
   if (backup.maxPingPongTurns != null) {
     fileCfg.session ??= {};
     fileCfg.session.agentToAgent ??= {};
     fileCfg.session.agentToAgent.maxPingPongTurns = backup.maxPingPongTurns;
+  } else {
+    delete fileCfg.session?.agentToAgent?.maxPingPongTurns;
   }
   if (backup.maxConcurrent != null) {
     fileCfg.agents ??= {};
     fileCfg.agents.defaults ??= {};
     fileCfg.agents.defaults.maxConcurrent = backup.maxConcurrent;
+  } else {
+    delete fileCfg.agents?.defaults?.maxConcurrent;
   }
   await writeRawConfigToDisk(fileCfg);
-  await fs3.unlink(backupPath);
+  await fs4.unlink(backupPath);
   console.log("[agentlife] restored config: maxPingPongTurns=%s, maxConcurrent=%s", backup.maxPingPongTurns ?? "default", backup.maxConcurrent ?? "default");
   return `config restored`;
 }
@@ -3092,8 +3580,8 @@ 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 configBackupDir = path6.join(ctx.stateDir, "agentlife");
+      const configBackupPath = path6.join(configBackupDir, "config-backup.json");
       const cfg = api.runtime.config.loadConfig();
       const currentPPT = cfg.session?.agentToAgent?.maxPingPongTurns;
       const currentMC = cfg.agents?.defaults?.maxConcurrent;
@@ -3103,8 +3591,8 @@ function registerConfigOptimizer(api, _state) {
         console.log("[agentlife] config already optimized, skipping");
         return;
       }
-      await fs3.mkdir(configBackupDir, { recursive: true });
-      await fs3.writeFile(configBackupPath, JSON.stringify({
+      await fs4.mkdir(configBackupDir, { recursive: true });
+      await fs4.writeFile(configBackupPath, JSON.stringify({
         maxPingPongTurns: currentPPT ?? null,
         maxConcurrent: currentMC ?? null
       }));
@@ -3129,7 +3617,7 @@ function registerConfigOptimizer(api, _state) {
     },
     stop: async (ctx) => {
       try {
-        const backupPath = path5.join(ctx.stateDir, "agentlife", "config-backup.json");
+        const backupPath = path6.join(ctx.stateDir, "agentlife", "config-backup.json");
         await restoreConfigFromBackup(api, backupPath);
       } catch {}
     }
@@ -3580,8 +4068,8 @@ function drainAccumulatorToSurfaces(state, sessionKey, surfaceIds) {
 }
 
 // notifications.ts
-import * as fs4 from "node:fs";
-import * as path6 from "node:path";
+import * as fs5 from "node:fs";
+import * as path7 from "node:path";
 var config;
 var recentNotifications = new Map;
 var DEBOUNCE_MS = 60000;
@@ -3589,8 +4077,8 @@ function loadConfig() {
   if (config !== undefined)
     return config;
   try {
-    const configPath = path6.join(process.env.HOME ?? "~", ".openclaw", "agentlife", "notification-config.json");
-    const raw = fs4.readFileSync(configPath, "utf-8");
+    const configPath = path7.join(process.env.HOME ?? "~", ".openclaw", "agentlife", "notification-config.json");
+    const raw = fs5.readFileSync(configPath, "utf-8");
     const parsed = JSON.parse(raw);
     if (parsed.serverUrl && parsed.apiKey) {
       config = { serverUrl: parsed.serverUrl, apiKey: parsed.apiKey };
@@ -3755,7 +4243,7 @@ function sendToInternalSession(state, agentId, message, idempotencyKey) {
     });
   }
 }
-var SKIP_WIDGET_CHECK = new Set(["agentlife", "agentlife-builder", "supervisor"]);
+var SKIP_WIDGET_CHECK = new Set(["agentlife", "agentlife-builder", "agentlife-vision", "supervisor"]);
 function registerActivityHooks(api, state) {
   api.on("llm_output", (event, ctx) => {
     if (state.disabled)
@@ -3821,6 +4309,17 @@ function registerActivityHooks(api, state) {
         console.log("[agentlife] action redirected to %s for %s (origin=%s)", actionSessionKey, actionSurfaceId, origin ? "set" : "legacy");
       }
     }
+    const dreamMatch = message.match(/\[action:\S+\]\s*surfaceId=awaiting-dream-input\b/);
+    if (dreamMatch) {
+      const labelMatch = message.match(/\blabel=([^\n]+)/);
+      const valueMatch = message.match(/\bvalue=([^\n]+)/);
+      const answer = (labelMatch?.[1] ?? valueMatch?.[1] ?? "").trim();
+      try {
+        emitTrigger(state, "userAnswered", { surfaceId: "awaiting-dream-input", answer });
+      } catch (e) {
+        console.warn("[agentlife] cold-start emit userAnswered failed: %s", e?.message);
+      }
+    }
   });
   api.on("llm_output", (event, ctx) => {
     if (state.disabled)
@@ -3853,6 +4352,39 @@ function registerActivityHooks(api, state) {
         })
       });
     }
+    let isCurrentColdStartSession = false;
+    if (agentId) {
+      try {
+        const cs = readState(state);
+        if (cs && cs.actionSessionKey === sessionKey && cs.phase !== "READY" && cs.phase !== "FAILED") {
+          isCurrentColdStartSession = true;
+        }
+      } catch {}
+    }
+    if (isCurrentColdStartSession && agentId) {
+      const lastText = texts.length > 0 ? texts[texts.length - 1].trim() : "";
+      const lastLine = lastText.split(`
+`).pop()?.trim() ?? "";
+      let marker = null;
+      if (/\bNO_SIGNAL\b/.test(lastText)) {
+        marker = "NO_SIGNAL";
+      } else if (TERMINAL_MARKERS.has(lastLine)) {
+        marker = lastLine;
+      } else if (TERMINAL_MARKERS.has(lastText)) {
+        marker = lastText;
+      }
+      try {
+        emitTrigger(state, "agentReplied", {
+          agentId,
+          sessionKey,
+          marker,
+          lastText: lastText.slice(0, 4000),
+          terminal: marker !== null
+        });
+      } catch (e) {
+        console.warn("[agentlife] cold-start emit agentReplied failed: %s", e?.message);
+      }
+    }
   }, { priority: 100 });
   api.on("before_tool_call", (event, ctx) => {
     if (state.disabled)
@@ -3897,6 +4429,26 @@ function registerActivityHooks(api, state) {
     if (event.toolName === "agentlife_push" && typeof event.params?.dsl === "string") {
       canvasDsl = event.params.dsl;
     }
+    if (!isError && agentId) {
+      let touchedMemory = false;
+      if (toolName === "exec") {
+        const command = event.params?.command ?? event.params?.script ?? "";
+        if (typeof command === "string" && /memory\/[\w.\-]+\.md/.test(command) && /(>>?|tee\b|cp\b|mv\b)/.test(command)) {
+          touchedMemory = true;
+        }
+      } else if (toolName === "write" || toolName === "edit" || toolName === "str_replace" || toolName === "apply_patch") {
+        const filePath = event.params?.path ?? event.params?.file_path ?? "";
+        if (/memory\/[\w.\-]+\.md$/.test(filePath))
+          touchedMemory = true;
+      }
+      if (touchedMemory) {
+        try {
+          emitTrigger(state, "memoryWritten", { agentId, sessionKey });
+        } catch (e) {
+          console.warn("[agentlife] cold-start emit memoryWritten failed: %s", e?.message);
+        }
+      }
+    }
     const resultStr = typeof event.result === "string" ? event.result : event.result != null ? JSON.stringify(event.result) : null;
     recordActivity(state, "tool_end", sessionKey, agentId, {
       toolName,
@@ -4682,31 +5234,31 @@ function startDailySweepService(state) {
 import * as crypto4 from "node:crypto";
 import * as fsSync3 from "node:fs";
 import { createRequire as createRequire3 } from "node:module";
-import * as os6 from "node:os";
-import * as path10 from "node:path";
+import * as os7 from "node:os";
+import * as path11 from "node:path";
 
 // gateway/web-app.ts
 import * as crypto3 from "node:crypto";
-import * as os5 from "node:os";
-import * as path9 from "node:path";
-import * as fs7 from "node:fs";
+import * as os6 from "node:os";
+import * as path10 from "node:path";
+import * as fs8 from "node:fs";
 
 // services/pairing-access-token.ts
 import * as crypto from "node:crypto";
-import * as fs5 from "node:fs";
-import * as os3 from "node:os";
-import * as path7 from "node:path";
+import * as fs6 from "node:fs";
+import * as os4 from "node:os";
+import * as path8 from "node:path";
 var cachedToken = null;
 function pairingAccessPath() {
-  return path7.join(os3.homedir(), ".openclaw", "agentlife", "pairing-access.json");
+  return path8.join(os4.homedir(), ".openclaw", "agentlife", "pairing-access.json");
 }
 function loadOrCreatePairingAccessToken() {
   if (cachedToken)
     return cachedToken;
   const filePath = pairingAccessPath();
   try {
-    if (fs5.existsSync(filePath)) {
-      const raw = fs5.readFileSync(filePath, "utf-8");
+    if (fs6.existsSync(filePath)) {
+      const raw = fs6.readFileSync(filePath, "utf-8");
       const obj = JSON.parse(raw);
       const token2 = typeof obj?.token === "string" ? obj.token : null;
       if (token2 && token2.length >= 32) {
@@ -4715,12 +5267,12 @@ function loadOrCreatePairingAccessToken() {
       }
     }
     const token = crypto.randomBytes(32).toString("base64url");
-    const dir = path7.dirname(filePath);
-    if (!fs5.existsSync(dir))
-      fs5.mkdirSync(dir, { recursive: true, mode: 448 });
-    fs5.writeFileSync(filePath, JSON.stringify({ token, createdAtMs: Date.now() }, null, 2), { mode: 384 });
+    const dir = path8.dirname(filePath);
+    if (!fs6.existsSync(dir))
+      fs6.mkdirSync(dir, { recursive: true, mode: 448 });
+    fs6.writeFileSync(filePath, JSON.stringify({ token, createdAtMs: Date.now() }, null, 2), { mode: 384 });
     try {
-      fs5.chmodSync(filePath, 384);
+      fs6.chmodSync(filePath, 384);
     } catch {}
     cachedToken = token;
     return token;
@@ -4733,15 +5285,15 @@ function loadOrCreatePairingAccessToken() {
 // services/cloudflared-supervisor.ts
 import { spawn, spawnSync } from "node:child_process";
 import * as crypto2 from "node:crypto";
-import * as fs6 from "node:fs";
-import * as os4 from "node:os";
-import * as path8 from "node:path";
-var AGENTLIFE_DIR = path8.join(os4.homedir(), ".openclaw", "agentlife");
-var DEVICE_FILE = path8.join(AGENTLIFE_DIR, "device.json");
-var TUNNEL_FILE = path8.join(AGENTLIFE_DIR, "tunnel.json");
-var BIN_DIR = path8.join(AGENTLIFE_DIR, "bin");
-var CLOUDFLARED_BIN = os4.platform() === "win32" ? "cloudflared.exe" : "cloudflared";
-var CLOUDFLARED_PATH = path8.join(BIN_DIR, CLOUDFLARED_BIN);
+import * as fs7 from "node:fs";
+import * as os5 from "node:os";
+import * as path9 from "node:path";
+var AGENTLIFE_DIR = path9.join(os5.homedir(), ".openclaw", "agentlife");
+var DEVICE_FILE = path9.join(AGENTLIFE_DIR, "device.json");
+var TUNNEL_FILE = path9.join(AGENTLIFE_DIR, "tunnel.json");
+var BIN_DIR = path9.join(AGENTLIFE_DIR, "bin");
+var CLOUDFLARED_BIN = os5.platform() === "win32" ? "cloudflared.exe" : "cloudflared";
+var CLOUDFLARED_PATH = path9.join(BIN_DIR, CLOUDFLARED_BIN);
 var API_BASE = process.env.AGENTLIFE_API_BASE || "https://api.agentlife.app";
 var RESTART_DELAY_MS = 5000;
 var STABLE_RUNTIME_MS = 60000;
@@ -4818,16 +5370,16 @@ async function doBootstrap() {
   return tunnelInfo;
 }
 function ensureDirs() {
-  if (!fs6.existsSync(AGENTLIFE_DIR))
-    fs6.mkdirSync(AGENTLIFE_DIR, { recursive: true, mode: 448 });
-  if (!fs6.existsSync(BIN_DIR))
-    fs6.mkdirSync(BIN_DIR, { recursive: true, mode: 448 });
+  if (!fs7.existsSync(AGENTLIFE_DIR))
+    fs7.mkdirSync(AGENTLIFE_DIR, { recursive: true, mode: 448 });
+  if (!fs7.existsSync(BIN_DIR))
+    fs7.mkdirSync(BIN_DIR, { recursive: true, mode: 448 });
 }
 function loadDeviceIdentity() {
-  if (!fs6.existsSync(DEVICE_FILE))
+  if (!fs7.existsSync(DEVICE_FILE))
     return null;
   try {
-    const raw = fs6.readFileSync(DEVICE_FILE, "utf-8");
+    const raw = fs7.readFileSync(DEVICE_FILE, "utf-8");
     const parsed = JSON.parse(raw);
     if (typeof parsed.deviceId === "string" && typeof parsed.deviceSecret === "string") {
       return { deviceId: parsed.deviceId, deviceSecret: parsed.deviceSecret };
@@ -4845,19 +5397,19 @@ function loadOrCreateDeviceIdentity() {
     deviceId: crypto2.randomUUID(),
     deviceSecret: crypto2.randomBytes(32).toString("base64url")
   };
-  fs6.writeFileSync(DEVICE_FILE, JSON.stringify(identity, null, 2), { mode: 384 });
+  fs7.writeFileSync(DEVICE_FILE, JSON.stringify(identity, null, 2), { mode: 384 });
   try {
-    fs6.chmodSync(DEVICE_FILE, 384);
+    fs7.chmodSync(DEVICE_FILE, 384);
   } catch {}
   console.log(`[cloudflared-supervisor] generated new device identity (deviceId=${identity.deviceId})`);
   return identity;
 }
 var AGENTLIFE_API_BASE = API_BASE;
 function loadCachedTunnel() {
-  if (!fs6.existsSync(TUNNEL_FILE))
+  if (!fs7.existsSync(TUNNEL_FILE))
     return null;
   try {
-    const raw = fs6.readFileSync(TUNNEL_FILE, "utf-8");
+    const raw = fs7.readFileSync(TUNNEL_FILE, "utf-8");
     const parsed = JSON.parse(raw);
     if (typeof parsed.subdomain === "string" && typeof parsed.hostname === "string" && typeof parsed.tunnelUrl === "string" && typeof parsed.tunnelToken === "string" && typeof parsed.provisionedAt === "number") {
       return parsed;
@@ -4866,9 +5418,9 @@ function loadCachedTunnel() {
   return null;
 }
 function persistTunnel(info) {
-  fs6.writeFileSync(TUNNEL_FILE, JSON.stringify(info, null, 2), { mode: 384 });
+  fs7.writeFileSync(TUNNEL_FILE, JSON.stringify(info, null, 2), { mode: 384 });
   try {
-    fs6.chmodSync(TUNNEL_FILE, 384);
+    fs7.chmodSync(TUNNEL_FILE, 384);
   } catch {}
 }
 async function provisionTunnel(identity) {
@@ -4905,14 +5457,14 @@ async function provisionTunnel(identity) {
   }
 }
 function ensureCloudflaredBinary() {
-  if (fs6.existsSync(CLOUDFLARED_PATH)) {
+  if (fs7.existsSync(CLOUDFLARED_PATH)) {
     try {
-      fs6.accessSync(CLOUDFLARED_PATH, fs6.constants.X_OK);
+      fs7.accessSync(CLOUDFLARED_PATH, fs7.constants.X_OK);
       return CLOUDFLARED_PATH;
     } catch {}
   }
-  const platform2 = os4.platform();
-  const arch2 = os4.arch();
+  const platform2 = os5.platform();
+  const arch2 = os5.arch();
   const release = detectCloudflaredRelease(platform2, arch2);
   if (!release) {
     console.warn(`[cloudflared-supervisor] unsupported platform: ${platform2}/${arch2}`);
@@ -4925,28 +5477,28 @@ function ensureCloudflaredBinary() {
   if (release.kind === "tgz") {
     const extracted = extractTgzCloudflared(release.tempPath, BIN_DIR);
     try {
-      fs6.unlinkSync(release.tempPath);
+      fs7.unlinkSync(release.tempPath);
     } catch {}
     if (!extracted)
       return null;
   } else {
     try {
-      fs6.renameSync(release.tempPath, CLOUDFLARED_PATH);
+      fs7.renameSync(release.tempPath, CLOUDFLARED_PATH);
     } catch (err) {
       console.warn(`[cloudflared-supervisor] rename failed: ${err?.message}`);
       return null;
     }
   }
   try {
-    fs6.chmodSync(CLOUDFLARED_PATH, 493);
+    fs7.chmodSync(CLOUDFLARED_PATH, 493);
   } catch {}
-  return fs6.existsSync(CLOUDFLARED_PATH) ? CLOUDFLARED_PATH : null;
+  return fs7.existsSync(CLOUDFLARED_PATH) ? CLOUDFLARED_PATH : null;
 }
 function detectCloudflaredRelease(platform2, arch2) {
   const base = "https://github.com/cloudflare/cloudflared/releases/latest/download";
   if (platform2 === "darwin") {
     const asset = arch2 === "arm64" ? "cloudflared-darwin-arm64.tgz" : "cloudflared-darwin-amd64.tgz";
-    return { url: `${base}/${asset}`, kind: "tgz", tempPath: path8.join(BIN_DIR, asset) };
+    return { url: `${base}/${asset}`, kind: "tgz", tempPath: path9.join(BIN_DIR, asset) };
   }
   if (platform2 === "linux") {
     const asset = arch2 === "arm64" ? "cloudflared-linux-arm64" : arch2 === "arm" ? "cloudflared-linux-arm" : arch2 === "x64" ? "cloudflared-linux-amd64" : null;
@@ -4970,11 +5522,11 @@ function downloadWithCurl(url, dest) {
   if (result.status !== 0) {
     console.warn(`[cloudflared-supervisor] curl failed (exit ${result.status}): ${result.stderr?.toString().slice(0, 200)}`);
     try {
-      fs6.unlinkSync(dest);
+      fs7.unlinkSync(dest);
     } catch {}
     return false;
   }
-  return fs6.existsSync(dest) && fs6.statSync(dest).size > 0;
+  return fs7.existsSync(dest) && fs7.statSync(dest).size > 0;
 }
 function extractTgzCloudflared(tgzPath, destDir) {
   const result = spawnSync("tar", ["-xzf", tgzPath, "-C", destDir], { stdio: "pipe" });
@@ -4982,7 +5534,7 @@ function extractTgzCloudflared(tgzPath, destDir) {
     console.warn(`[cloudflared-supervisor] tar extract failed (exit ${result.status}): ${result.stderr?.toString().slice(0, 200)}`);
     return false;
   }
-  return fs6.existsSync(CLOUDFLARED_PATH);
+  return fs7.existsSync(CLOUDFLARED_PATH);
 }
 function startCloudflaredProcess(binPath, tunnelToken) {
   if (state.stopped)
@@ -5039,11 +5591,11 @@ var MIME_TYPES = {
 };
 function mintBootstrapToken() {
   const bootstrapToken = crypto3.randomBytes(32).toString("base64url");
-  const devicesDir = path9.join(os5.homedir(), ".openclaw", "devices");
-  const bootstrapPath = path9.join(devicesDir, "bootstrap.json");
-  if (!fs7.existsSync(devicesDir))
-    fs7.mkdirSync(devicesDir, { recursive: true });
-  const registry = fs7.existsSync(bootstrapPath) ? JSON.parse(fs7.readFileSync(bootstrapPath, "utf-8")) : {};
+  const devicesDir = path10.join(os6.homedir(), ".openclaw", "devices");
+  const bootstrapPath = path10.join(devicesDir, "bootstrap.json");
+  if (!fs8.existsSync(devicesDir))
+    fs8.mkdirSync(devicesDir, { recursive: true });
+  const registry = fs8.existsSync(bootstrapPath) ? JSON.parse(fs8.readFileSync(bootstrapPath, "utf-8")) : {};
   registry[bootstrapToken] = {
     token: bootstrapToken,
     profile: {
@@ -5052,15 +5604,15 @@ function mintBootstrapToken() {
     },
     issuedAtMs: Date.now()
   };
-  fs7.writeFileSync(bootstrapPath, JSON.stringify(registry, null, 2));
+  fs8.writeFileSync(bootstrapPath, JSON.stringify(registry, null, 2));
   return bootstrapToken;
 }
 function registerWebApp(api) {
-  const pluginRoot = path9.resolve(path9.dirname(api.source), "..");
-  const appRoot = path9.join(pluginRoot, "web-build");
-  const hasWebBuild = fs7.existsSync(appRoot);
-  const indexPath = hasWebBuild ? path9.join(appRoot, "index.html") : null;
-  const hasIndex = !!(indexPath && fs7.existsSync(indexPath));
+  const pluginRoot = path10.resolve(path10.dirname(api.source), "..");
+  const appRoot = path10.join(pluginRoot, "web-build");
+  const hasWebBuild = fs8.existsSync(appRoot);
+  const indexPath = hasWebBuild ? path10.join(appRoot, "index.html") : null;
+  const hasIndex = !!(indexPath && fs8.existsSync(indexPath));
   if (!hasWebBuild) {
     api.logger.info("[agentlife] web-build/ not found — /agentlife/pair will still register; static dashboard disabled");
   } else if (!hasIndex) {
@@ -5068,8 +5620,8 @@ function registerWebApp(api) {
   }
   let gatewayToken = "";
   try {
-    const configPath = path9.join(__require("node:os").homedir(), ".openclaw", "openclaw.json");
-    const raw = JSON.parse(fs7.readFileSync(configPath, "utf-8"));
+    const configPath = path10.join(__require("node:os").homedir(), ".openclaw", "openclaw.json");
+    const raw = JSON.parse(fs8.readFileSync(configPath, "utf-8"));
     gatewayToken = raw?.gateway?.auth?.token || "";
   } catch {}
   loadOrCreatePairingAccessToken();
@@ -5185,16 +5737,16 @@ function registerWebApp(api) {
         return true;
       }
       const relative = urlPath.replace(/^\/agentlife\/?/, "") || "index.html";
-      const filePath = path9.resolve(appRoot, relative);
+      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 = path9.extname(target).toLowerCase();
+      const target = fs8.existsSync(filePath) && fs8.statSync(filePath).isFile() ? filePath : indexPath;
+      const ext = path10.extname(target).toLowerCase();
       const contentType = MIME_TYPES[ext] || "application/octet-stream";
-      let content = fs7.readFileSync(target);
+      let content = fs8.readFileSync(target);
       if (target === indexPath) {
         setTimeout(approveLatest, 2000);
         setTimeout(approveLatest, 5000);
@@ -5283,9 +5835,9 @@ Setup code: ${setupCode}
   api.registerService({
     id: "agentlife-auto-pair",
     start: async (ctx) => {
-      const devicesDir = path10.join(os6.homedir(), ".openclaw", "devices");
-      const pendingPath = path10.join(devicesDir, "pending.json");
-      const pairedPath = path10.join(devicesDir, "paired.json");
+      const devicesDir = path11.join(os7.homedir(), ".openclaw", "devices");
+      const pendingPath = path11.join(devicesDir, "pending.json");
+      const pairedPath = path11.join(devicesDir, "paired.json");
       const pollInterval = 3000;
       const withAdmin = (arr) => {
         const base = Array.isArray(arr) ? arr.filter((s) => typeof s === "string") : [];
@@ -5383,7 +5935,7 @@ Setup code: ${setupCode}
 
 // hooks/bootstrap.ts
 var SKIP_GUIDANCE_AGENTS = new Set(["agentlife"]);
-var SKIP_AGENTS_MD_INJECTION = new Set(["agentlife", "agentlife-builder", "quick", "supervisor"]);
+var SKIP_AGENTS_MD_INJECTION = new Set(["agentlife", "agentlife-builder", "agentlife-vision", "quick", "supervisor"]);
 function registerBootstrapHook(api, state2) {
   api.registerService({
     id: "agentlife-bootstrap-hook",
@@ -5537,11 +6089,11 @@ function registerBootstrapHookImpl(api, state2) {
 }
 
 // tools/widget-push.ts
-var PROVISIONED_IDS = new Set(PROVISIONED_AGENTS.map((a) => a.id));
+var PROVISIONED_IDS2 = new Set(PROVISIONED_AGENTS.map((a) => a.id));
 function isKnownAgent(state2, agentId, api) {
   if (state2.agentRegistry.size === 0)
     return true;
-  if (PROVISIONED_IDS.has(agentId) || state2.agentRegistry.has(agentId))
+  if (PROVISIONED_IDS2.has(agentId) || state2.agentRegistry.has(agentId))
     return true;
   try {
     const cfg = api.runtime.config.loadConfig();
@@ -5824,12 +6376,53 @@ function extractWidgetText(meta) {
 }
 
 // hooks/prompt-state.ts
+var lastEmittedAnswerByKey = new Map;
+function lastUserMessage(messages) {
+  for (let i = messages.length - 1;i >= 0; i--) {
+    const m = messages[i];
+    if (m?.role !== "user")
+      continue;
+    if (typeof m.content === "string")
+      return m.content;
+    if (Array.isArray(m.content)) {
+      const parts = [];
+      for (const block of m.content) {
+        if (typeof block === "string")
+          parts.push(block);
+        else if (block?.type === "text" && typeof block.text === "string")
+          parts.push(block.text);
+      }
+      return parts.join(`
+`);
+    }
+  }
+  return "";
+}
 function registerPromptStateHook(api, state2) {
-  api.on("before_prompt_build", (_event, ctx) => {
+  api.on("before_prompt_build", (event, ctx) => {
     if (state2.disabled)
       return;
     if (!isAgentlifeSession(ctx?.sessionKey))
       return;
+    const sessionKey = ctx?.sessionKey;
+    if (sessionKey) {
+      const messages = event?.messages ?? [];
+      const latest = lastUserMessage(messages);
+      if (latest && lastEmittedAnswerByKey.get(sessionKey) !== latest) {
+        const actionMatch = latest.match(/\[action:\S+\]\s*surfaceId=awaiting-dream-input\b/);
+        if (actionMatch) {
+          const labelMatch = latest.match(/\blabel=([^\n]+)/);
+          const valueMatch = latest.match(/\bvalue=([^\n]+)/);
+          const answer = (labelMatch?.[1] ?? valueMatch?.[1] ?? "").trim();
+          lastEmittedAnswerByKey.set(sessionKey, latest);
+          try {
+            emitTrigger(state2, "userAnswered", { surfaceId: "awaiting-dream-input", answer });
+          } catch (e) {
+            console.warn("[agentlife] cold-start emit userAnswered (prompt-build) failed: %s", e?.message);
+          }
+        }
+      }
+    }
     const agentId = ctx?.agentId;
     const isOrchestrator = agentId === "agentlife";
     if (isOrchestrator)
@@ -5849,8 +6442,8 @@ function registerPromptStateHook(api, state2) {
 }
 
 // gateway/agents.ts
-import * as fs8 from "node:fs";
-import * as path11 from "node:path";
+import * as fs9 from "node:fs";
+import * as path12 from "node:path";
 function registerAgentGateway(api, state2) {
   api.registerGatewayMethod("agentlife.createAgent", async ({ params, respond }) => {
     const id = typeof params?.id === "string" ? params.id.trim() : "";
@@ -5938,6 +6531,16 @@ function registerAgentGateway(api, state2) {
       configFields.push("subagents");
     if (identity)
       configFields.push("identity");
+    if (!existing) {
+      const provisionedIds = new Set(PROVISIONED_AGENTS.map((a) => a.id));
+      if (!provisionedIds.has(id)) {
+        try {
+          emitTrigger(state2, "agentRegistered", { agentId: id, name, model });
+        } catch (e) {
+          console.warn("[agentlife] cold-start emit agentRegistered failed: %s", e?.message);
+        }
+      }
+    }
     respond(true, { status, id, name, model, workspace, description, ...configFields.length ? { configFields } : {} });
   });
   api.registerGatewayMethod("agentlife.deleteAgent", async ({ params, respond }) => {
@@ -6000,10 +6603,10 @@ function registerAgentGateway(api, state2) {
       state2.agentDbs.delete(id);
     }
     if (state2.dbBaseDir) {
-      const dbPath = path11.join(state2.dbBaseDir, `${id}.db`);
+      const dbPath = path12.join(state2.dbBaseDir, `${id}.db`);
       try {
-        if (fs8.existsSync(dbPath)) {
-          fs8.unlinkSync(dbPath);
+        if (fs9.existsSync(dbPath)) {
+          fs9.unlinkSync(dbPath);
           cleanup.agentDbDeleted = true;
         }
       } catch (e) {
@@ -6029,6 +6632,17 @@ function registerAgentGateway(api, state2) {
       await saveRegistryToDisk(state2);
     }
     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);
+    try {
+      const provisionedIds2 = new Set(PROVISIONED_AGENTS.map((a) => a.id));
+      let remaining = 0;
+      for (const aid of state2.agentRegistry.keys()) {
+        if (!provisionedIds2.has(aid))
+          remaining++;
+      }
+      emitTrigger(state2, "agentDeleted", { agentId: id, remaining });
+    } catch (e) {
+      console.warn("[agentlife] cold-start emit agentDeleted failed: %s", e?.message);
+    }
     respond(true, { status: "deleted", id, removedFromConfig, removedFromRegistry, cleanup });
   });
   api.registerGatewayMethod("agentlife.agents", ({ respond }) => {
@@ -6329,7 +6943,7 @@ function registerUsageGateway(api, state2) {
 var guidedDismissSent = new Set;
 var warnedMissingOrigin = new Set;
 function registerSurfacesGateway(api, state2) {
-  api.registerGatewayMethod("agentlife.surfaces", ({ respond, context }) => {
+  api.registerGatewayMethod("agentlife.surfaces", ({ params, respond, context }) => {
     captureBridge(context);
     const now = Date.now();
     const activeSurfaceIds = [];
@@ -6338,23 +6952,21 @@ function registerSurfacesGateway(api, state2) {
       respond(true, { surfaces: [] });
       return;
     }
-    const LOADING_TTL_MS = 2 * 60 * 1000;
-    for (const [surfaceId, meta] of state2.surfaceDb.entries()) {
-      const headerLine = meta.lines[0] ?? "";
-      if (/\bstate=loading\b/.test(headerLine) && now - meta.updatedAt > LOADING_TTL_MS) {
-        const agentId = state2.surfaceDb.getAgentId(surfaceId);
-        meta.lines[0] = headerLine.replace(/\bstate=loading\b/, "state=error");
-        state2.surfaceDb.set(surfaceId, { ...meta, updatedAt: now });
-        recordSurfaceEvent(state2, 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);
-      }
-    }
+    const visibility = params?.visibility === "paywall" ? "paywall" : "dashboard";
+    const FLOW_INPUT_IDS = new Set(["onboarding-domain", "awaiting-dream-input"]);
+    const isFlowInput = (id) => FLOW_INPUT_IDS.has(id) || id.startsWith("warmup-") || id.startsWith("dismiss-alt-");
     for (const [surfaceId, meta] of state2.surfaceDb.entries()) {
       if (isExpired(meta, now))
         continue;
       const headerLine = meta.lines[0] ?? "";
-      if (/\binput\b/.test(headerLine))
+      const isInput = /\binput\b/.test(headerLine);
+      if (isInput && !isFlowInput(surfaceId))
         continue;
+      if (visibility === "dashboard" && surfaceId.startsWith("vision-")) {
+        const visible = state2.surfaceDb.getDashboardVisible(surfaceId);
+        if (!visible)
+          continue;
+      }
       if (meta.lines.length > 0) {
         surfaceEntries.push({ surfaceId, dsl: meta.lines.join(`
 `) });
@@ -6492,7 +7104,12 @@ function registerSurfacesGateway(api, state2) {
       automations = db.prepare("SELECT id, type, name, path FROM automations WHERE surfaceId = ? AND status != 'removed'").all(surfaceId);
     } catch {}
     guidedDismissSent.delete(surfaceId);
-    state2.surfaceDb.delete(surfaceId);
+    const isVision = surfaceId.startsWith("vision-");
+    if (isVision) {
+      state2.surfaceDb.setDashboardVisible(surfaceId, false);
+    } else {
+      state2.surfaceDb.delete(surfaceId);
+    }
     broadcastDelete(surfaceId);
     try {
       enqueueCleanupTasks(state2, surfaceId, agentId, cronId, automations);
@@ -6500,7 +7117,7 @@ function registerSurfacesGateway(api, state2) {
       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 (reason=%s)", surfaceId, taskCount, reason ?? "none");
+    console.log("[agentlife] dismiss: %s %s, %d cleanup tasks enqueued (reason=%s)", surfaceId, isVision ? "hidden from dashboard (kept for paywall)" : "deleted", taskCount, reason ?? "none");
     respond(true, { surfaceId, dismissed: true });
     processCleanupTasks(state2, surfaceId).catch((e) => console.warn("[agentlife] dismiss cleanup processor error:", e?.message));
   }, { scope: "operator.write" });
@@ -6652,12 +7269,12 @@ function registerAutomationsGateway(api, state2) {
 }
 
 // gateway/admin.ts
-import * as fs9 from "node:fs/promises";
+import * as fs10 from "node:fs/promises";
 import * as fsSync4 from "node:fs";
-import * as os7 from "node:os";
-import * as path12 from "node:path";
+import * as os8 from "node:os";
+import * as path13 from "node:path";
 function pluginConfigPath() {
-  return path12.join(os7.homedir(), ".openclaw", "agentlife", "plugin-config.json");
+  return path13.join(os8.homedir(), ".openclaw", "agentlife", "plugin-config.json");
 }
 function readPluginConfig() {
   try {
@@ -6667,7 +7284,7 @@ function readPluginConfig() {
   }
 }
 function writePluginConfig(config2) {
-  const dir = path12.dirname(pluginConfigPath());
+  const dir = path13.dirname(pluginConfigPath());
   fsSync4.mkdirSync(dir, { recursive: true });
   fsSync4.writeFileSync(pluginConfigPath(), JSON.stringify(config2, null, 2));
 }
@@ -6766,7 +7383,7 @@ function registerAdminGateway(api, state2) {
   api.registerGatewayMethod("agentlife.uninstall", async ({ respond }) => {
     try {
       const cleaned = [];
-      const baseDir = state2.agentlifeStateDir ?? path12.join(os7.homedir(), ".openclaw", "agentlife");
+      const baseDir = state2.agentlifeStateDir ?? path13.join(os8.homedir(), ".openclaw", "agentlife");
       const identity = loadDeviceIdentity();
       if (!identity) {
         cleaned.push("server deprovision skipped (no device identity)");
@@ -6831,7 +7448,7 @@ function registerAdminGateway(api, state2) {
       } catch {
         cleaned.push("agent config cleanup skipped");
       }
-      const backupPath = path12.join(baseDir, "config-backup.json");
+      const backupPath = path13.join(baseDir, "config-backup.json");
       try {
         cleaned.push(await restoreConfigFromBackup(api, backupPath));
       } catch {
@@ -6854,35 +7471,35 @@ function registerAdminGateway(api, state2) {
         dbPath,
         dbPath ? `${dbPath}-wal` : null,
         dbPath ? `${dbPath}-shm` : null,
-        path12.join(baseDir, "config-backup.json"),
-        path12.join(baseDir, "notification-config.json"),
-        path12.join(baseDir, "canvas-node-identity.json")
+        path13.join(baseDir, "config-backup.json"),
+        path13.join(baseDir, "notification-config.json"),
+        path13.join(baseDir, "canvas-node-identity.json")
       ].filter(Boolean);
       for (const fp of stateFiles) {
         try {
-          await fs9.unlink(fp);
-          cleaned.push(`deleted ${path12.basename(fp)}`);
+          await fs10.unlink(fp);
+          cleaned.push(`deleted ${path13.basename(fp)}`);
         } catch {}
       }
       if (state2.dbBaseDir) {
         try {
-          await fs9.rm(state2.dbBaseDir, { recursive: true, force: true });
+          await fs10.rm(state2.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 ?? path12.join(os7.homedir(), ".openclaw", `workspace-${agent.id}`);
+        const wsDir = agent.workspaceDir ?? path13.join(os8.homedir(), ".openclaw", `workspace-${agent.id}`);
         try {
-          await fs9.rm(wsDir, { recursive: true, force: true });
+          await fs10.rm(wsDir, { recursive: true, force: true });
           cleaned.push(`deleted workspace ${agent.id}`);
         } catch {}
       }
       try {
-        const remaining = await fs9.readdir(baseDir);
+        const remaining = await fs10.readdir(baseDir);
         if (remaining.length === 0) {
-          await fs9.rmdir(baseDir);
+          await fs10.rmdir(baseDir);
           cleaned.push("deleted agentlife state directory");
         }
       } catch {}
@@ -7124,6 +7741,295 @@ function parseOffset2(offset) {
   }
 }
 
+// gateway/providers.ts
+import * as fs11 from "node:fs";
+import * as os9 from "node:os";
+import * as path14 from "node:path";
+import {
+  upsertApiKeyProfile,
+  applyAuthProfileConfig
+} from "openclaw/plugin-sdk/provider-auth-api-key";
+var catalogCache = null;
+var catalogPromise = null;
+var modelsCache = null;
+var modelsPromise = null;
+function configPath() {
+  return path14.join(os9.homedir(), ".openclaw", "openclaw.json");
+}
+function readConfig() {
+  try {
+    return JSON.parse(fs11.readFileSync(configPath(), "utf-8"));
+  } catch {
+    return {};
+  }
+}
+function writeConfig(cfg) {
+  fs11.writeFileSync(configPath(), JSON.stringify(cfg, null, 2) + `
+`, "utf-8");
+}
+async function fetchCatalog(run) {
+  const result = await run(["openclaw", "infer", "model", "providers", "--json"], { timeoutMs: 60000 });
+  if ((result?.code ?? 0) !== 0)
+    throw new Error(`providers catalog query failed`);
+  const raw = (result?.stdout ?? "").trim();
+  const jsonStart = raw.indexOf("[");
+  if (jsonStart < 0)
+    throw new Error("providers catalog: no JSON array in output");
+  const parsed = JSON.parse(raw.slice(jsonStart));
+  if (!Array.isArray(parsed))
+    throw new Error("providers catalog: not an array");
+  return parsed;
+}
+async function ensureCatalog(run) {
+  if (catalogCache)
+    return catalogCache;
+  if (!run)
+    return [];
+  if (!catalogPromise) {
+    catalogPromise = fetchCatalog(run).then((c) => {
+      catalogCache = c;
+      return c;
+    }).catch((err) => {
+      catalogPromise = null;
+      throw err;
+    });
+  }
+  return catalogPromise;
+}
+async function fetchModels(run) {
+  const result = await run(["openclaw", "infer", "model", "list", "--json"], { timeoutMs: 60000 });
+  if ((result?.code ?? 0) !== 0)
+    throw new Error(`models list query failed`);
+  const raw = (result?.stdout ?? "").trim();
+  const jsonStart = raw.indexOf("[");
+  if (jsonStart < 0)
+    throw new Error("models list: no JSON array in output");
+  const parsed = JSON.parse(raw.slice(jsonStart));
+  if (!Array.isArray(parsed))
+    throw new Error("models list: not an array");
+  return parsed;
+}
+async function ensureModels(run) {
+  if (modelsCache)
+    return modelsCache;
+  if (!run)
+    return [];
+  if (!modelsPromise) {
+    modelsPromise = fetchModels(run).then((m) => {
+      modelsCache = m;
+      return m;
+    }).catch((err) => {
+      modelsPromise = null;
+      throw err;
+    });
+  }
+  return modelsPromise;
+}
+function authenticatedProviders() {
+  const cfg = readConfig();
+  const profiles = cfg?.auth?.profiles ?? {};
+  const out = new Set;
+  for (const entry of Object.values(profiles)) {
+    const e = entry;
+    if (typeof e?.provider === "string" && typeof e?.mode === "string") {
+      out.add(e.provider);
+    }
+  }
+  return out;
+}
+function configuredApiKeyProviders() {
+  const cfg = readConfig();
+  const profiles = cfg?.auth?.profiles ?? {};
+  const out = new Set;
+  for (const entry of Object.values(profiles)) {
+    const e = entry;
+    if (e?.mode === "api_key" && typeof e.provider === "string") {
+      out.add(e.provider);
+    }
+  }
+  return out;
+}
+async function probeAnthropic(apiKey) {
+  const ctl = new AbortController;
+  const timer = setTimeout(() => ctl.abort(), 1e4);
+  try {
+    const res = await fetch("https://api.anthropic.com/v1/messages", {
+      method: "POST",
+      headers: {
+        "x-api-key": apiKey,
+        "anthropic-version": "2023-06-01",
+        "content-type": "application/json"
+      },
+      body: JSON.stringify({
+        model: "claude-haiku-4-5",
+        max_tokens: 1,
+        messages: [{ role: "user", content: "ping" }]
+      }),
+      signal: ctl.signal
+    });
+    if (res.ok)
+      return { ok: true };
+    const body = await res.text().catch(() => "");
+    return { ok: false, error: `Anthropic ${res.status}: ${body.slice(0, 240) || res.statusText}` };
+  } catch (err) {
+    return { ok: false, error: err?.message ?? String(err) };
+  } finally {
+    clearTimeout(timer);
+  }
+}
+async function probeOpenAI(apiKey) {
+  const ctl = new AbortController;
+  const timer = setTimeout(() => ctl.abort(), 1e4);
+  try {
+    const res = await fetch("https://api.openai.com/v1/models", {
+      headers: { authorization: `Bearer ${apiKey}` },
+      signal: ctl.signal
+    });
+    if (res.ok)
+      return { ok: true };
+    const body = await res.text().catch(() => "");
+    return { ok: false, error: `OpenAI ${res.status}: ${body.slice(0, 240) || res.statusText}` };
+  } catch (err) {
+    return { ok: false, error: err?.message ?? String(err) };
+  } finally {
+    clearTimeout(timer);
+  }
+}
+function canProbe(provider) {
+  return provider === "anthropic" || provider === "openai";
+}
+async function probe(provider, apiKey) {
+  if (provider === "anthropic")
+    return probeAnthropic(apiKey);
+  if (provider === "openai")
+    return probeOpenAI(apiKey);
+  return { ok: false, error: `test not supported for provider: ${provider}` };
+}
+function registerProvidersGateway(api, state2) {
+  const run = state2.runCommand;
+  if (run) {
+    ensureCatalog(run).catch(() => {});
+    ensureModels(run).catch(() => {});
+  }
+  api.registerGatewayMethod("agentlife.providers.list", async ({ respond }) => {
+    try {
+      const [catalog, configured] = await Promise.all([
+        ensureCatalog(run ?? null),
+        Promise.resolve(configuredApiKeyProviders())
+      ]);
+      const providers = catalog.map((entry) => ({
+        provider: entry.provider,
+        modelCount: entry.count,
+        available: entry.available,
+        configured: configured.has(entry.provider),
+        canProbe: canProbe(entry.provider)
+      }));
+      respond(true, { providers });
+    } catch (err) {
+      respond(false, { error: err?.message ?? String(err) });
+    }
+  }, { scope: "operator.read" });
+  api.registerGatewayMethod("agentlife.providers.set", async ({ params, respond }) => {
+    const provider = typeof params?.provider === "string" ? params.provider.trim() : "";
+    const apiKey = typeof params?.apiKey === "string" ? params.apiKey.trim() : "";
+    if (!provider)
+      return respond(false, { error: "provider is empty" });
+    if (!apiKey)
+      return respond(false, { error: "apiKey is empty" });
+    try {
+      const catalog = await ensureCatalog(run ?? null);
+      if (catalog.length > 0 && !catalog.some((e) => e.provider === provider)) {
+        return respond(false, { error: `unknown provider: ${provider}` });
+      }
+    } catch {}
+    try {
+      const profileId = upsertApiKeyProfile({ provider, input: apiKey });
+      const cfg = readConfig();
+      const nextCfg = applyAuthProfileConfig(cfg, {
+        profileId,
+        provider,
+        mode: "api_key",
+        preferProfileFirst: true
+      });
+      writeConfig(nextCfg);
+      respond(true, { provider, configured: true, profileId });
+    } catch (err) {
+      respond(false, { error: err?.message ?? String(err) });
+    }
+  }, { scope: "operator.write" });
+  api.registerGatewayMethod("agentlife.providers.delete", ({ params, respond }) => {
+    const provider = typeof params?.provider === "string" ? params.provider.trim() : "";
+    if (!provider)
+      return respond(false, { error: "provider is empty" });
+    try {
+      const cfg = readConfig();
+      const profiles = cfg?.auth?.profiles;
+      if (profiles && typeof profiles === "object") {
+        for (const [id, entry] of Object.entries(profiles)) {
+          if (entry?.provider === provider)
+            delete profiles[id];
+        }
+      }
+      if (cfg?.auth?.order && typeof cfg.auth.order === "object") {
+        delete cfg.auth.order[provider];
+      }
+      writeConfig(cfg);
+      respond(true, { provider, configured: false });
+    } catch (err) {
+      respond(false, { error: err?.message ?? String(err) });
+    }
+  }, { scope: "operator.write" });
+  api.registerGatewayMethod("agentlife.providers.test", async ({ params, respond }) => {
+    const provider = typeof params?.provider === "string" ? params.provider.trim() : "";
+    const apiKey = typeof params?.apiKey === "string" ? params.apiKey.trim() : "";
+    if (!provider)
+      return respond(false, { error: "provider is empty" });
+    if (!apiKey)
+      return respond(true, { ok: false, error: "apiKey required — type a key before testing" });
+    try {
+      const result = await probe(provider, apiKey);
+      respond(true, { ok: result.ok, error: result.error });
+    } catch (err) {
+      respond(true, { ok: false, error: err?.message ?? String(err) });
+    }
+  }, { scope: "operator.read" });
+  api.registerGatewayMethod("agentlife.models.list", async ({ respond }) => {
+    try {
+      const [all, authed] = await Promise.all([
+        ensureModels(run ?? null),
+        Promise.resolve(authenticatedProviders())
+      ]);
+      const filtered = all.filter((m) => authed.has(m.provider));
+      const DATE_SUFFIX = /-(?:\d{4}-\d{2}-\d{2}|\d{8})$/;
+      const undatedIds = new Set(filtered.filter((m) => !DATE_SUFFIX.test(m.id)).map((m) => m.id));
+      const deduped = filtered.filter((m) => {
+        if (!DATE_SUFFIX.test(m.id))
+          return true;
+        return !undatedIds.has(m.id.replace(DATE_SUFFIX, ""));
+      });
+      respond(true, { models: deduped });
+    } catch (err) {
+      respond(false, { error: err?.message ?? String(err) });
+    }
+  }, { scope: "operator.read" });
+  api.registerGatewayMethod("agentlife.providers.loginCodex", async ({ respond }) => {
+    if (!run)
+      return respond(false, { error: "runCommand unavailable" });
+    try {
+      const result = await run(["openclaw", "capability", "model", "auth", "login", "--provider", "openai-codex"], { timeoutMs: 180000 });
+      const combined = `${result?.stdout ?? ""}
+${result?.stderr ?? ""}`;
+      const urlMatch = combined.match(/https:\/\/\S+/);
+      if ((result?.code ?? 0) !== 0 && !urlMatch) {
+        return respond(false, { error: (result?.stderr ?? "").trim() || "codex login failed" });
+      }
+      respond(true, { url: urlMatch?.[0] ?? null, completed: (result?.code ?? 0) === 0 });
+    } catch (err) {
+      respond(false, { error: err?.message ?? String(err) });
+    }
+  }, { scope: "operator.write" });
+}
+
 // index.ts
 var currentState = null;
 var registered = false;
@@ -7133,7 +8039,7 @@ var stopQualityCheckPoller = null;
 var stopCloudflared = null;
 function resolveInternalModel(api) {
   try {
-    const pluginCfgPath = path13.join(homedir9(), ".openclaw", "agentlife", "plugin-config.json");
+    const pluginCfgPath = path15.join(homedir11(), ".openclaw", "agentlife", "plugin-config.json");
     try {
       const raw = __require("node:fs").readFileSync(pluginCfgPath, "utf-8");
       const pluginCfg = JSON.parse(raw);
@@ -7169,7 +8075,7 @@ function register(api) {
     return;
   }
   registered = true;
-  const fallbackDir = path13.join(homedir9(), ".openclaw", "agentlife");
+  const fallbackDir = path15.join(homedir11(), ".openclaw", "agentlife");
   const state2 = {
     surfaceDb: null,
     agentRegistry: new Map,
@@ -7179,9 +8085,9 @@ function register(api) {
     agentDbs: new Map,
     historyDb: null,
     agentlifeStateDir: fallbackDir,
-    registryFilePath: path13.join(fallbackDir, "agent-registry.json"),
-    dbBaseDir: path13.join(fallbackDir, "db"),
-    historyDbPath: path13.join(fallbackDir, "agentlife.db"),
+    registryFilePath: path15.join(fallbackDir, "agent-registry.json"),
+    dbBaseDir: path15.join(fallbackDir, "db"),
+    historyDbPath: path15.join(fallbackDir, "agentlife.db"),
     runCommand: api.runtime.system?.runCommandWithTimeout ?? null,
     enqueueSystemEvent: null,
     requestHeartbeatNow: null,
@@ -7212,6 +8118,7 @@ function register(api) {
       stopObservability = startObservabilityService(state2);
       stopDailySweep = startDailySweepService(state2);
       stopQualityCheckPoller = startQualityCheckPoller(state2);
+      await initColdStartMachine(state2, api.runtime, console.log);
     }
   });
   registerConfigOptimizer(api, state2);
@@ -7238,6 +8145,7 @@ function register(api) {
         stopCloudflared();
         stopCloudflared = null;
       }
+      shutdownColdStartMachine();
       closeAllDbs(state2);
     }
   });
@@ -7254,8 +8162,9 @@ function register(api) {
   registerAutomationsGateway(api, state2);
   registerFollowupsGateway(api, state2);
   registerAdminGateway(api, state2);
+  registerProvidersGateway(api, state2);
   registerWebApp(api);
-  const notifyConfigPath = path13.join(fallbackDir, "notification-config.json");
+  const notifyConfigPath = path15.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() : "";
@@ -7263,35 +8172,45 @@ function register(api) {
       return respond(false, { error: "missing serverUrl or apiKey" });
     }
     try {
-      const { writeFileSync: writeFileSync7, mkdirSync: mkdirSync6 } = __require("node:fs");
-      mkdirSync6(path13.dirname(notifyConfigPath), { recursive: true });
-      writeFileSync7(notifyConfigPath, JSON.stringify({ serverUrl, apiKey }));
+      const { writeFileSync: writeFileSync8, mkdirSync: mkdirSync6 } = __require("node:fs");
+      mkdirSync6(path15.dirname(notifyConfigPath), { recursive: true });
+      writeFileSync8(notifyConfigPath, JSON.stringify({ serverUrl, apiKey }));
     } catch {}
     respond(true, { registered: true });
   }, { scope: "operator.write" });
-  api.registerGatewayMethod("agentlife.vision.ensure", async ({ respond }) => {
+  api.registerGatewayMethod("agentlife.coldStart.observe", ({ respond }) => {
     try {
       if (!currentState) {
         return respond(false, { error: "plugin state not initialized" });
       }
-      const result = await ensureVisionPosters(currentState, api.runtime, console.log);
-      respond(true, result);
+      respond(true, observeColdStart(currentState));
     } catch (e) {
       respond(false, { code: "internal_error", message: e?.message ?? String(e) });
     }
   }, { scope: "operator.read" });
-  api.registerGatewayMethod("agentlife.vision.retryWarmup", async ({ respond }) => {
+  api.registerGatewayMethod("agentlife.coldStart.retry", async ({ respond }) => {
     try {
       if (!currentState) {
         return respond(false, { error: "plugin state not initialized" });
       }
-      resetBootstrapCooldown();
-      const result = await ensureVisionPosters(currentState, api.runtime, console.log);
-      respond(true, result);
+      respond(true, await retryColdStart(currentState));
     } catch (e) {
       respond(false, { code: "internal_error", message: e?.message ?? String(e) });
     }
   }, { scope: "operator.read" });
+  api.registerGatewayMethod("agentlife.coldStart.advance", ({ params, respond }) => {
+    try {
+      if (!currentState)
+        return respond(false, { error: "plugin state not initialized" });
+      const kind = typeof params?.kind === "string" ? params.kind : null;
+      if (!kind)
+        return respond(false, { error: "missing kind" });
+      emitTrigger(currentState, kind, params?.payload ?? {});
+      respond(true, { enqueued: true });
+    } catch (e) {
+      respond(false, { code: "internal_error", message: e?.message ?? String(e) });
+    }
+  }, { scope: "operator.admin" });
 }
 export {
   register as default,