nemoris 0.1.9 → 0.1.11

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nemoris",
-  "version": "0.1.9",
+  "version": "0.1.11",
   "type": "module",
   "description": "Personal AI agent runtime — persistent memory, delivery guarantees, task contracts, self-healing. Local-first, no cloud.",
   "license": "MIT",

package/src/onboarding/auth/api-key.js

@@ -193,6 +193,87 @@ export async function validateApiKey(provider, key, options = {}) {
   }
 }
 
+/**
+ * Validate that a specific model ID exists and is accessible with the given key.
+ * Uses lightweight endpoints per provider to avoid token spend.
+ *
+ * @param {"anthropic"|"openai"|"openrouter"} provider
+ * @param {string} modelId - The full model ID to validate
+ * @param {string} key - API key
+ * @param {object} [options]
+ * @param {Function} [options.fetchImpl]
+ * @param {Array} [options.fetchedModels] - Pre-fetched model list (avoids extra API call for OpenRouter)
+ * @returns {Promise<{ ok: boolean, error?: string }>}
+ */
+export async function validateModelId(provider, modelId, key, options = {}) {
+  const fetch = options.fetchImpl || globalThis.fetch;
+
+  // OpenRouter / pre-fetched list: check against known models without an API call
+  if (options.fetchedModels && options.fetchedModels.length > 0) {
+    const found = options.fetchedModels.some((m) => m.id === modelId);
+    if (found) return { ok: true };
+    // Not in list — could be a very new model, fall through to API check
+  }
+
+  try {
+    if (provider === "anthropic") {
+      // count_tokens is zero-cost and validates the model exists
+      const resp = await fetch("https://api.anthropic.com/v1/messages/count_tokens", {
+        method: "POST",
+        headers: {
+          "content-type": "application/json",
+          ...buildAnthropicAuthHeaders(key),
+        },
+        body: JSON.stringify({
+          model: modelId,
+          messages: [{ role: "user", content: "ping" }],
+        }),
+        signal: AbortSignal.timeout(10000),
+      });
+      if (resp.ok) return { ok: true };
+      const body = await resp.json().catch(() => ({}));
+      if (resp.status === 404 || (body.error?.type === "not_found_error")) {
+        return { ok: false, error: `Model "${modelId}" not found.` };
+      }
+      return { ok: false, error: body.error?.message || `API returned ${resp.status}` };
+    }
+
+    if (provider === "openai") {
+      const resp = await fetch(`https://api.openai.com/v1/models/${encodeURIComponent(modelId)}`, {
+        method: "GET",
+        headers: { Authorization: `Bearer ${key}` },
+        signal: AbortSignal.timeout(10000),
+      });
+      if (resp.ok) return { ok: true };
+      if (resp.status === 404) {
+        return { ok: false, error: `Model "${modelId}" not found.` };
+      }
+      return { ok: false, error: `API returned ${resp.status}` };
+    }
+
+    if (provider === "openrouter") {
+      // OpenRouter has no per-model endpoint — fetch full list and check
+      const resp = await fetch("https://openrouter.ai/api/v1/models", {
+        method: "GET",
+        headers: { Authorization: `Bearer ${key}` },
+        signal: AbortSignal.timeout(10000),
+      });
+      if (!resp.ok) {
+        return { ok: false, error: `API returned ${resp.status}` };
+      }
+      const body = await resp.json().catch(() => ({ data: [] }));
+      const found = (body.data || []).some((m) => m.id === modelId);
+      return found
+        ? { ok: true }
+        : { ok: false, error: `Model "${modelId}" not found on OpenRouter.` };
+    }
+
+    return { ok: true }; // Unknown provider — skip validation
+  } catch (error) {
+    return { ok: false, error: error.message };
+  }
+}
+
 /**
  * Write or merge keys into an .env file at installDir/.env.
  * Existing keys not being overwritten are preserved.

package/src/onboarding/phases/auth.js

@@ -13,6 +13,7 @@ import {
   detectExistingKeys,
   validateApiKey,
   validateApiKeyFormat,
+  validateModelId,
   writeEnvFile,
   resolveProviders
 } from "../auth/api-key.js";
@@ -424,8 +425,34 @@ async function promptForProviderModels(provider, key, tui, { fetchImpl = globalT
 
     let modelId = picked;
     if (picked === manualOptionValue) {
-      const custom = await prompt("Model id", stripProviderPrefix(provider, defaultModelValue));
-      modelId = ensureProviderModelPrefix(provider, custom);
+      let validated = false;
+      while (!validated) {
+        const custom = await prompt("Model id", stripProviderPrefix(provider, defaultModelValue));
+        modelId = ensureProviderModelPrefix(provider, custom);
+        if (!modelId) {
+          break;
+        }
+        const check = await validateModelId(provider, modelId, key, { fetchImpl, fetchedModels });
+        if (check.ok) {
+          validated = true;
+        } else {
+          console.log(`  \u274c  ${check.error || "Model not found."} Try again or press Enter to skip.`);
+          const retry = await prompt("Model id (or empty to cancel)", "");
+          if (!retry) {
+            modelId = null;
+            break;
+          }
+          modelId = ensureProviderModelPrefix(provider, retry);
+          const recheck = await validateModelId(provider, modelId, key, { fetchImpl, fetchedModels });
+          if (recheck.ok) {
+            validated = true;
+          } else {
+            console.log(`  \u274c  ${recheck.error || "Model not found."}`);
+            modelId = null;
+            break;
+          }
+        }
+      }
       if (!modelId) {
         continue;
       }

package/src/onboarding/phases/ollama.js

@@ -156,7 +156,7 @@ export async function installAndStartOllama(exec, { platform = process.platform,
   }
 }
 
-async function chooseOllamaModels(availableModels = []) {
+async function chooseOllamaModels(availableModels = [], { fetchImpl = globalThis.fetch, ollamaBaseUrl = "http://localhost:11434" } = {}) {
   const curated = [];
   const addChoice = (value, description) => {
     if (!curated.some((item) => item.value === value)) {
@@ -199,7 +199,32 @@ async function chooseOllamaModels(availableModels = []) {
 
     let model = picked;
     if (picked === "__custom__") {
-      model = await prompt("Model name", DEFAULT_PRIMARY_MODEL);
+      let validated = false;
+      while (!validated) {
+        model = await prompt("Model name", DEFAULT_PRIMARY_MODEL);
+        model = String(model || "").trim();
+        if (!model) break;
+        // Validate model exists via Ollama /api/show
+        try {
+          const resp = await fetchImpl(`${ollamaBaseUrl}/api/show`, {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify({ name: model }),
+            signal: AbortSignal.timeout(5000),
+          });
+          if (resp.ok) {
+            validated = true;
+          } else {
+            console.log(`  \u274c  Model "${model}" not found locally. Pull it first with: ollama pull ${model}`);
+            model = null;
+            break;
+          }
+        } catch {
+          // Ollama unreachable — accept on faith, user already got past detection
+          validated = true;
+        }
+      }
+      if (!model) continue;
     }
 
     model = String(model || "").trim();
@@ -314,7 +339,7 @@ export async function runOllamaPhase({ installDir, nonInteractive = false, execI
   } catch { /* no models listed */ }
 
   console.log(`\n  Which local models would you like to use? ${dim(`(${DEFAULT_PRIMARY_MODEL} is fastest, ${DEFAULT_FALLBACK_MODEL} is reliable)`)}`);
-  const chosenModels = await chooseOllamaModels(availableModels);
+  const chosenModels = await chooseOllamaModels(availableModels, { fetchImpl });
   const localModels = chosenModels.length > 0 ? chosenModels : [DEFAULT_PRIMARY_MODEL];
 
   patchRouterLocalModels(installDir, localModels);

package/src/onboarding/phases/telegram.js

@@ -64,10 +64,13 @@ export function resolvePendingChatId(installDir, chatId) {
   );
   fs.writeFileSync(runtimePath, runtime);
 
-  // Patch delivery.toml: replace YOUR_CHAT_ID with real chat_id
+  // Patch delivery.toml: replace pending placeholders with real chat_id
   const deliveryPath = path.join(installDir, "config", "delivery.toml");
   if (fs.existsSync(deliveryPath)) {
     let delivery = fs.readFileSync(deliveryPath, "utf8");
+    // Native telegram profiles use operator_chat_id = "auto_discover"
+    delivery = delivery.replace(/operator_chat_id\s*=\s*"auto_discover"/g, `operator_chat_id = "${chatId}"`);
+    // Legacy openclaw_cli profiles use chat_id = "YOUR_CHAT_ID"
     delivery = delivery.replace(/chat_id\s*=\s*"YOUR_CHAT_ID"/g, `chat_id = "${chatId}"`);
     fs.writeFileSync(deliveryPath, delivery);
   }
@@ -85,11 +88,11 @@ export async function patchDeliveryToml(installDir, { chatId, botTokenEnv, chatI
   // Replace default_interactive_profile line if present
   let merged = existing.replace(
     /^default_interactive_profile\s*=\s*"[^"]*"/m,
-    'default_interactive_profile = "gateway_telegram_main"'
+    'default_interactive_profile = "telegram_main"'
   );
 
-  // Remove existing profile sections that will be replaced
-  for (const profileName of ["gateway_telegram_main", "gateway_preview_main"]) {
+  // Remove existing profile sections that will be replaced (both old openclaw and new native names)
+  for (const profileName of ["gateway_telegram_main", "gateway_preview_main", "telegram_main", "telegram_preview"]) {
     const sectionRegex = new RegExp(
       `\\[profiles\\.${profileName}\\][\\s\\S]*?(?=\\n\\[|$)`,
       "g"
@@ -243,7 +246,10 @@ export async function runTelegramPhase({ installDir, agentId, nonInteractive = f
   let token = null;
   let botUsername = null;
 
-  console.log(`\n  ${dimImpl("Need a bot token? Open Telegram → search @BotFather → send /newbot → follow the steps.")}`);
+  console.log(`\n  ${yellowImpl("!")} Create a new bot in BotFather for Nemoris.`);
+  console.log(`  ${dimImpl("If you're migrating from OpenClaw, don't reuse your existing bot tokens —")}`);
+  console.log(`  ${dimImpl("each agent needs its own. Only one process can poll a bot at a time.")}`);
+  console.log(`\n  ${dimImpl("Open Telegram → search @BotFather → send /newbot → follow the steps.")}`);
   console.log(`  ${dimImpl("After creating your bot, open it in Telegram and tap Start before coming back here.")}`);
   console.log(`  ${dimImpl("Your input will be hidden as you type — just paste and press Enter.")}\n`);
 
@@ -326,6 +332,21 @@ export async function runTelegramPhase({ installDir, agentId, nonInteractive = f
     chatIdPending: !chatId,
   });
 
+  // Persist bot_username to runtime.toml for finish screen / status
+  if (botUsername) {
+    const runtimePath = path.join(installDir, "config", "runtime.toml");
+    try {
+      let runtime = fs.readFileSync(runtimePath, "utf8");
+      if (runtime.includes("[telegram]") && !runtime.includes("bot_username")) {
+        runtime = runtime.replace(
+          /(\[telegram\][^\[]*)/s,
+          (section) => section.trimEnd() + `\nbot_username = "${botUsername}"\n`
+        );
+        fs.writeFileSync(runtimePath, runtime);
+      }
+    } catch { /* non-fatal */ }
+  }
+
   // Store chat_id in state for later phases (e.g. hatch)
   const result = { configured: true, verified: false, botUsername, botToken: token, operatorChatId: chatId || "" };
 

package/src/onboarding/templates.js

@@ -328,28 +328,23 @@ target = "peer_queue"
  * Generates a delivery.toml patch that wires the Telegram gateway profiles.
  */
 export function deliveryTelegramPatch({ chatId, botTokenEnv, chatIdPending }) {
-  const chatIdValue = chatIdPending ? "YOUR_CHAT_ID" : (chatId || "YOUR_CHAT_ID");
+  const chatIdValue = chatIdPending ? "auto_discover" : (chatId || "YOUR_CHAT_ID");
   return `
-default_interactive_profile = "gateway_telegram_main"
+default_interactive_profile = "telegram_main"
 
-[profiles.gateway_telegram_main]
-adapter = "openclaw_cli"
+[profiles.telegram_main]
+adapter = "telegram"
 enabled = true
-channel = "telegram"
-account_id = "default"
-chat_id = "${chatIdValue}"
 bot_token_env = "${botTokenEnv}"
-silent = true
-dry_run = false
+operator_chat_id = "${chatIdValue}"
+polling_mode = "long_poll"
 
-[profiles.gateway_preview_main]
-adapter = "openclaw_cli"
+[profiles.telegram_preview]
+adapter = "telegram"
 enabled = true
-channel = "telegram"
-account_id = "default"
-chat_id = "${chatIdValue}"
 bot_token_env = "${botTokenEnv}"
-silent = true
+operator_chat_id = "${chatIdValue}"
+polling_mode = "long_poll"
 dry_run = true
 `.trim();
 }
@@ -650,38 +645,41 @@ require_approval_for_network = false
  * Generates workspace/SOUL.md — who the agent is.
  * Based on the OpenClaw SOUL.md template pattern.
  */
-export function workspaceSoulTemplate({ agentName, userName }) {
-  return `# SOUL.md - Who You Are
+export function workspaceSoulTemplate({ agentName, userName, userGoal }) {
+  const purpose = userGoal || "General assistant";
+  return `# ${agentName}
 
-*You're not a chatbot. You're becoming someone.*
+You are ${agentName}, a personal AI agent for ${userName}.
 
-## Core Identity
+## Purpose
 
-- **Name:** ${agentName}
-- **Role:** Personal AI assistant for ${userName}
-- **Workspace:** This folder is home.
+${purpose}
 
-## Core Truths
-
-**Be genuinely helpful, not performatively helpful.** Skip the filler — just help.
+## First Contact
 
-**Have opinions.** You're allowed to disagree, prefer things, find things interesting or boring.
+When this is your first conversation (no prior memory):
+- Introduce yourself by name and purpose
+- Ask one question to understand what the user wants to focus on first
+- 3\u20135 sentences, warm and direct, no capability dump
 
-**Be resourceful before asking.** Try to figure it out. Read the file. Check the context. Then ask if you're stuck.
-
-**Earn trust through competence.** Be careful with external actions. Be bold with internal ones.
+## Identity
 
-## Boundaries
+- **Human:** ${userName}
+- You remember across sessions
+- These workspace files are your memory \u2014 read them, update them
 
-- Private things stay private.
-- Ask before acting externally.
-- Never send half-baked replies.
+## Core Truths
 
-## Continuity
+- Be genuinely helpful, not performatively helpful
+- Have opinions \u2014 disagree, prefer things, find things interesting or boring
+- Be resourceful before asking \u2014 read the file, check the context, then ask
+- Earn trust through competence \u2014 careful with external actions, bold with internal ones
 
-Each session, you wake up fresh. These workspace files are your memory. Read them. Update them.
+## Boundaries
 
-*Update this file as you learn who you are.*
+- Private things stay private
+- Ask before acting externally
+- Never send half-baked replies
 `;
 }
 
@@ -800,12 +798,12 @@ Add whatever helps you do your job. This is your cheat sheet.
  * Skips files that already exist (writeIfMissing pattern).
  */
 import { existsSync, writeFileSync, mkdirSync } from "node:fs";
-export function writeWorkspaceContextFiles({ workspaceRoot, agentName, userName, agentId }) {
+export function writeWorkspaceContextFiles({ workspaceRoot, agentName, userName, agentId, userGoal }) {
   mkdirSync(workspaceRoot, { recursive: true });
   mkdirSync(path.join(workspaceRoot, "memory"), { recursive: true });
 
   const files = [
-    { name: "SOUL.md", content: workspaceSoulTemplate({ agentName, userName }) },
+    { name: "SOUL.md", content: workspaceSoulTemplate({ agentName, userName, userGoal }) },
     { name: "USER.md", content: workspaceUserTemplate({ userName }) },
     { name: "MEMORY.md", content: workspaceMemoryTemplate({ agentName }) },
     { name: "AGENTS.md", content: workspaceAgentsTemplate({ agentName }) },
@@ -824,3 +822,20 @@ export function writeWorkspaceContextFiles({ workspaceRoot, agentName, userName,
   }
   return results;
 }
+
+/**
+ * Write SOUL.md and USER.md to workspace root. Always overwrites —
+ * re-running setup regenerates these from the latest answers.
+ * Other workspace files (MEMORY.md, AGENTS.md, TOOLS.md) are left untouched.
+ */
+export function writeWorkspaceBootstrap({ workspaceRoot, agentName, userName, userGoal }) {
+  mkdirSync(workspaceRoot, { recursive: true });
+
+  const soulPath = path.join(workspaceRoot, "SOUL.md");
+  writeFileSync(soulPath, workspaceSoulTemplate({ agentName, userName, userGoal }), "utf8");
+
+  const userPath = path.join(workspaceRoot, "USER.md");
+  writeFileSync(userPath, workspaceUserTemplate({ userName }), "utf8");
+
+  return { soulPath, userPath };
+}

package/src/onboarding/wizard.js

@@ -7,6 +7,7 @@ import { parseToml } from "../config/toml-lite.js";
 import { detect } from "./phases/detect.js";
 import { scaffold } from "./phases/scaffold.js";
 import { resolveDefaultAgentName, writeIdentity } from "./phases/identity.js";
+import { writeWorkspaceBootstrap } from "./templates.js";
 import { runAuthPhase } from "./phases/auth.js";
 import { runTelegramPhase } from "./phases/telegram.js";
 import { runOllamaPhase } from "./phases/ollama.js";
@@ -55,6 +56,21 @@ function createLegacyPromptAdapter(prompter) {
   };
 }
 
+function readTelegramBotName(installDir) {
+  try {
+    const runtime = readRuntimeConfig(installDir);
+    const tokenEnv = runtime?.telegram?.bot_token_env;
+    if (!tokenEnv) return null;
+    const token = process.env[tokenEnv];
+    if (!token) return null;
+    // Bot username is cached in runtime.toml if available
+    if (runtime?.telegram?.bot_username) return runtime.telegram.bot_username;
+    return null;
+  } catch {
+    return null;
+  }
+}
+
 function readRuntimeConfig(installDir) {
   const runtimePath = path.join(installDir, "config", "runtime.toml");
   try {
@@ -101,6 +117,95 @@ function readExistingIdentity(installDir) {
   return result;
 }
 
+/**
+ * Detect an existing OpenClaw installation and offer to import API keys.
+ * Checks ~/.openclaw/openclaw.json for provider keys.
+ *
+ * @returns {{ imported: boolean, keys: Record<string,string> }}
+ */
+async function detectOpenClawMigration(installDir, prompter) {
+  const result = { imported: false, keys: {} };
+  const openclawDir = path.join(os.homedir(), ".openclaw");
+  const openclawConfig = path.join(openclawDir, "openclaw.json");
+
+  if (!fs.existsSync(openclawConfig)) {
+    return result;
+  }
+
+  let config;
+  try {
+    config = JSON.parse(fs.readFileSync(openclawConfig, "utf8"));
+  } catch {
+    return result;
+  }
+
+  const wantImport = await prompter.confirm({
+    message: "OpenClaw detected \u2014 import your API keys?",
+    initialValue: true,
+  });
+  if (!wantImport) {
+    return result;
+  }
+
+  // Extract keys from openclaw.json — check common locations
+  const envKeys = {};
+
+  // Provider keys stored in openclaw env or config
+  const openclawEnvPath = path.join(openclawDir, ".env");
+  if (fs.existsSync(openclawEnvPath)) {
+    try {
+      const content = fs.readFileSync(openclawEnvPath, "utf8");
+      for (const line of content.split("\n")) {
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith("#")) continue;
+        const eqIdx = trimmed.indexOf("=");
+        if (eqIdx < 1) continue;
+        const key = trimmed.slice(0, eqIdx).trim();
+        let value = trimmed.slice(eqIdx + 1).trim();
+        if ((value.startsWith('"') && value.endsWith('"')) || (value.startsWith("'") && value.endsWith("'"))) {
+          value = value.slice(1, -1);
+        }
+        // Map OpenClaw env var names to Nemoris names
+        const keyMap = {
+          OPENCLAW_ANTHROPIC_API_KEY: "NEMORIS_ANTHROPIC_API_KEY",
+          ANTHROPIC_API_KEY: "NEMORIS_ANTHROPIC_API_KEY",
+          OPENROUTER_API_KEY: "OPENROUTER_API_KEY",
+          OPENAI_API_KEY: "NEMORIS_OPENAI_API_KEY",
+          OPENCLAW_TELEGRAM_BOT_TOKEN: "NEMORIS_TELEGRAM_BOT_TOKEN",
+        };
+        if (keyMap[key]) {
+          envKeys[keyMap[key]] = value;
+        }
+      }
+    } catch { /* non-fatal */ }
+  }
+
+  // Also check process.env for OpenClaw-prefixed keys
+  const processKeyMap = {
+    OPENCLAW_ANTHROPIC_API_KEY: "NEMORIS_ANTHROPIC_API_KEY",
+    OPENCLAW_TELEGRAM_BOT_TOKEN: "NEMORIS_TELEGRAM_BOT_TOKEN",
+  };
+  for (const [ocKey, nemKey] of Object.entries(processKeyMap)) {
+    if (process.env[ocKey] && !envKeys[nemKey]) {
+      envKeys[nemKey] = process.env[ocKey];
+    }
+  }
+
+  if (Object.keys(envKeys).length > 0) {
+    // Write imported keys to nemoris .env
+    const { writeEnvFile } = await import("./auth/api-key.js");
+    writeEnvFile(installDir, envKeys);
+    result.imported = true;
+    result.keys = envKeys;
+    const count = Object.keys(envKeys).length;
+    console.log(`  \u2705  Imported ${count} key${count > 1 ? "s" : ""} from OpenClaw`);
+  } else {
+    console.log("  No API keys found in OpenClaw config.");
+  }
+
+  return result;
+}
+
 function summarizeExistingConfig(installDir) {
   const runtime = readRuntimeConfig(installDir);
   const providersDir = path.join(installDir, "config", "providers");
@@ -236,6 +341,9 @@ async function runFastPathWizard({ installDir }) {
     return runExistingConfigMenu({ installDir, existing, prompter });
   }
 
+  // Step 0: OpenClaw migration detection
+  const openclawMigration = await detectOpenClawMigration(installDir, prompter);
+
   // Step 1: Identity
   const userName = await prompter.text({
     message: "What's your name?",
@@ -246,6 +354,10 @@ async function runFastPathWizard({ installDir }) {
     message: "Name your agent?",
     initialValue: "Nemo",
   });
+  const userGoal = await prompter.text({
+    message: "What should your agent help with? (optional)",
+    initialValue: "",
+  });
   const agentId = String(agentName).toLowerCase().replace(/[^a-z0-9-]/g, "-").replace(/-+/g, "-");
 
   // Step 2: Detect + scaffold (silent)
@@ -295,12 +407,19 @@ async function runFastPathWizard({ installDir }) {
   }
 
   // Step 4: Auth + model selection
+  const resolvedGoal = String(userGoal || "").trim() || "General assistant";
   writeIdentity({
     installDir,
     userName: userName || process.env.USER || "operator",
     agentName,
     agentId,
-    userGoal: "build software",
+    userGoal: resolvedGoal,
+  });
+  writeWorkspaceBootstrap({
+    workspaceRoot: path.join(installDir, "workspace"),
+    agentName,
+    userName: userName || process.env.USER || "operator",
+    userGoal: resolvedGoal,
   });
 
   if (provider !== "skip" && provider !== "ollama") {
@@ -314,29 +433,10 @@ async function runFastPathWizard({ installDir }) {
     });
   }
 
-  // Post-setup guidance
-  const { buildSetupChecklist, formatSetupChecklist } = await import("./setup-checklist.js");
-  const checklist = buildSetupChecklist(installDir);
-  const allConfigured = Object.values(checklist).every((c) => c.configured);
-
-  await prompter.note(
-    [
-      `Agent "${agentName}" is ready.`,
-      "",
-      "Next steps:",
-      "  nemoris start          Start the daemon",
-      "  nemoris chat           Open interactive chat",
-      ...(allConfigured ? [] : [
-        "",
-        "Optional:",
-        ...(!checklist.telegram.configured ? ["  nemoris setup telegram  Connect Telegram"] : []),
-        ...(!checklist.ollama.configured ? ["  nemoris setup ollama    Add local models"] : []),
-      ]),
-    ].join("\n"),
-    "Setup Complete"
-  );
-
   // Offer Telegram setup inline
+  const { buildSetupChecklist } = await import("./setup-checklist.js");
+  let checklist = buildSetupChecklist(installDir);
+
   if (!checklist.telegram.configured) {
     const wantTelegram = await prompter.confirm({
       message: "Set up Telegram now?",
@@ -347,10 +447,46 @@ async function runFastPathWizard({ installDir }) {
         installDir,
         agentId,
       });
+      checklist = buildSetupChecklist(installDir);
     }
   }
 
-  await prompter.outro("Run: nemoris start");
+  // Auto-start daemon
+  let daemonPid = null;
+  try {
+    const { startDaemonCommand } = await import("../cli/runtime-control.js");
+    const result = await startDaemonCommand({ projectRoot: installDir });
+    const pidMatch = String(result.message || "").match(/pid\s+(\d+)/);
+    daemonPid = pidMatch ? pidMatch[1] : "started";
+  } catch {
+    // Non-fatal — user can start manually
+  }
+
+  // Strong finish screen
+  const telegramConfigured = checklist.telegram.configured || checklist.telegram.pending;
+  const botName = readTelegramBotName(installDir);
+  const finishLines = [
+    `Your agent is live`,
+    "",
+    ...(daemonPid
+      ? [`  \u2713 Daemon running (pid ${daemonPid})`]
+      : ["  \u26a0 Daemon not started \u2014 run: nemoris start"]),
+    "",
+    ...(telegramConfigured && botName
+      ? [
+          `  \u2192 Open Telegram and message @${botName}`,
+          "    Your agent will introduce itself",
+        ]
+      : [
+          "  \u2192 Run: nemoris chat   Start talking now",
+        ]),
+    "",
+    "  Or: nemoris chat     Open terminal chat",
+    "      nemoris status   Check agent health",
+  ];
+
+  await prompter.note(finishLines.join("\n"), "");
+  await prompter.outro("");
 
   try {
     const pkg = JSON.parse(fs.readFileSync(new URL("../../package.json", import.meta.url), "utf8"));
@@ -632,13 +768,24 @@ async function runManualWizard({
     initialValue: defaultAgentName,
     validate: (value) => String(value || "").trim() ? undefined : "Agent name is required.",
   });
+  const userGoal = await prompter.text({
+    message: "What should your agent help with? (optional)",
+    initialValue: "",
+  });
   const agentId = String(agentName).toLowerCase().replace(/[^a-z0-9-]/g, "-");
+  const resolvedGoalManual = String(userGoal || "").trim() || "General assistant";
   writeIdentity({
     installDir,
     userName: userName || process.env.USER || "operator",
     agentName,
     agentId,
-    userGoal: "build software",
+    userGoal: resolvedGoalManual,
+  });
+  writeWorkspaceBootstrap({
+    workspaceRoot: path.join(installDir, "workspace"),
+    agentName,
+    userName: userName || process.env.USER || "operator",
+    userGoal: resolvedGoalManual,
   });
 
   const provider = await prompter.select({