nemoris 0.1.4 → 0.1.5

package/package.json

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

package/src/cli-main.js

@@ -840,7 +840,7 @@ async function serveDaemon(mode = "dry-run", intervalMs = "30000", installDir =
       const execApprovalGate = handler.getExecApprovalGate();
       localDaemon.executor.setExecApprovalGate(execApprovalGate);
       localExecutor.setExecApprovalGate(execApprovalGate);
-      telegramPoller = startTelegramPolling({ botToken: token, handler });
+      telegramPoller = startTelegramPolling({ botToken: token, handler, projectRoot: root });
       await stateStore.setMeta("telegram_inbound", { status: "READY", mode: "polling" });
       console.log(JSON.stringify({ service: "telegram_inbound", status: "READY", mode: "polling" }));
     } else if (token && telegramConfig.webhookUrl) {
@@ -2684,6 +2684,16 @@ export async function main(argv = process.argv) {
     await showModelsOverview(resolveRuntimeInstallDir());
   } else if (command === "setup" && rest[0] === "telegram") {
     await setupTelegram();
+  } else if (command === "setup" && rest[0] === "provider") {
+    const { runProviderSubWizard } = await import("./onboarding/wizard.js");
+    return runProviderSubWizard({
+      installDir: resolveRuntimeInstallDir(),
+    });
+  } else if (command === "setup" && rest[0] === "ollama") {
+    const { runOllamaSubWizard } = await import("./onboarding/wizard.js");
+    return runOllamaSubWizard({
+      installDir: resolveRuntimeInstallDir(),
+    });
   } else if (command === "telegram" && rest[0] === "whoami") {
     await telegramWhoami();
   } else if (command === "uninstall") {
@@ -2698,6 +2708,7 @@ export async function main(argv = process.argv) {
       installDir: resolveRuntimeInstallDir(),
       nonInteractive,
       advanced,
+      manual: rest.includes("--manual"),
       acceptRisk: rest.includes("--accept-risk"),
       flow: parseFlagValue(rest, "--flow"),
       anthropicKey: parseFlagValue(rest, "--anthropic-key"),
@@ -2713,6 +2724,7 @@ export async function main(argv = process.argv) {
       installDir: resolveRuntimeInstallDir(),
       nonInteractive,
       advanced,
+      manual: rest.includes("--manual"),
       acceptRisk: rest.includes("--accept-risk"),
       flow: parseFlagValue(rest, "--flow"),
       anthropicKey: parseFlagValue(rest, "--anthropic-key"),

package/src/onboarding/lock.js

@@ -33,16 +33,17 @@ export function readLock(installDir) {
 }
 
 export function writeWizardMetadata(installDir, metadata) {
-  const lock = readLock(installDir) || {};
-  const updated = {
-    ...lock,
+  const existing = readLock(installDir) || {};
+  const state = {
+    ...existing,
     lastRunAt: metadata.lastRunAt || new Date().toISOString(),
     lastRunVersion: metadata.lastRunVersion || "",
     lastRunCommand: metadata.lastRunCommand || "setup",
     lastRunMode: metadata.lastRunMode || "quickstart",
     lastRunFlow: metadata.lastRunFlow || "interactive",
+    capabilities: { ...(existing.capabilities || {}), ...(metadata.capabilities || {}) },
   };
-  writeLock(installDir, updated);
+  writeLock(installDir, state);
 }
 
 export function deleteLock(installDir) {

package/src/onboarding/phases/telegram.js

@@ -12,6 +12,7 @@ import { getMe, whoami } from "../../runtime/telegram-inbound.js";
 import { writeEnvFile } from "../auth/api-key.js";
 import { isDaemonRunning, setDaemonEnv } from "../platform.js";
 import { writeTomlSection } from "../toml-writer.js";
+import { deliveryTelegramPatch } from "../templates.js";
 import {
   confirm, prompt, promptSecret, select, waitForEnter,
   bold, green, red, yellow, dim, cyan, progressLine,
@@ -47,6 +48,87 @@ export function patchRuntimeToml(installDir, telegramToml) {
   writeTomlSection(runtimePath, "telegram", telegramToml);
 }
 
+/**
+ * Called at runtime when the daemon receives the first inbound Telegram
+ * message and chat_id_pending is set. Writes the discovered chat_id
+ * back to runtime.toml and delivery.toml, clearing the pending flag.
+ */
+export function resolvePendingChatId(installDir, chatId) {
+  // Patch runtime.toml: add operator_chat_id, remove chat_id_pending
+  const runtimePath = path.join(installDir, "config", "runtime.toml");
+  let runtime = fs.readFileSync(runtimePath, "utf8");
+  runtime = runtime.replace(/chat_id_pending\s*=\s*true\n?/, "");
+  runtime = runtime.replace(
+    /(\[telegram\][^\[]*)/s,
+    (section) => section.trimEnd() + `\noperator_chat_id = "${chatId}"\n`
+  );
+  fs.writeFileSync(runtimePath, runtime);
+
+  // Patch delivery.toml: replace YOUR_CHAT_ID with real chat_id
+  const deliveryPath = path.join(installDir, "config", "delivery.toml");
+  if (fs.existsSync(deliveryPath)) {
+    let delivery = fs.readFileSync(deliveryPath, "utf8");
+    delivery = delivery.replace(/chat_id\s*=\s*"YOUR_CHAT_ID"/g, `chat_id = "${chatId}"`);
+    fs.writeFileSync(deliveryPath, delivery);
+  }
+}
+
+export async function patchDeliveryToml(installDir, { chatId, botTokenEnv, chatIdPending }) {
+  const deliveryPath = path.join(installDir, "config", "delivery.toml");
+  let existing = "";
+  try {
+    existing = fs.readFileSync(deliveryPath, "utf8");
+  } catch { /* no existing file */ }
+
+  const patch = deliveryTelegramPatch({ chatId, botTokenEnv, chatIdPending });
+
+  // Replace default_interactive_profile line if present
+  let merged = existing.replace(
+    /^default_interactive_profile\s*=\s*"[^"]*"/m,
+    'default_interactive_profile = "gateway_telegram_main"'
+  );
+
+  // Remove existing profile sections that will be replaced
+  for (const profileName of ["gateway_telegram_main", "gateway_preview_main"]) {
+    const sectionRegex = new RegExp(
+      `\\[profiles\\.${profileName}\\][\\s\\S]*?(?=\\n\\[|$)`,
+      "g"
+    );
+    merged = merged.replace(sectionRegex, "");
+  }
+
+  // Append patch
+  merged = merged.trimEnd() + "\n\n" + patch + "\n";
+
+  fs.writeFileSync(deliveryPath, merged);
+}
+
+export async function discoverChatIdFromUpdates(token, options = {}) {
+  const { timeoutSeconds = 30, fetchImpl = globalThis.fetch } = options;
+  const deadline = Date.now() + timeoutSeconds * 1000;
+  let offset = 0;
+
+  while (Date.now() < deadline) {
+    const remaining = Math.max(1, Math.ceil((deadline - Date.now()) / 1000));
+    const pollSeconds = Math.min(remaining, 5);
+    const url = `https://api.telegram.org/bot${token}/getUpdates?offset=${offset}&timeout=${pollSeconds}`;
+    try {
+      const resp = await fetchImpl(url);
+      const data = await resp.json();
+      if (data.ok && data.result?.length > 0) {
+        for (const update of data.result) {
+          offset = update.update_id + 1;
+          const chatId = update.message?.chat?.id;
+          if (chatId) return String(chatId);
+        }
+      }
+    } catch {
+      await new Promise((r) => setTimeout(r, 1000));
+    }
+  }
+  return null;
+}
+
 async function sendTestMessage(token, chatId, text, { fetchImpl = globalThis.fetch } = {}) {
   try {
     const url = `https://api.telegram.org/bot${token}/sendMessage`;
@@ -177,7 +259,8 @@ export async function runTelegramPhase({ installDir, agentId, nonInteractive = f
       token = raw;
       botUsername = me.username;
       console.log(progressLineImpl("Token validated", `@${me.username}`));
-      console.log(`  ${dimImpl(TELEGRAM_START_INSTRUCTION)}`);
+      console.log(`\n  ${dimImpl("Open this link to start your bot:")}`);
+      console.log(`  ${cyanImpl(`https://t.me/${me.username}?start=setup`)}\n`);
     } else {
       console.log(`  ${redImpl("✗")} That token didn't work — double-check it in BotFather and try again.`);
       console.log(`  ${dimImpl("Try again or press Enter to skip.")}`);
@@ -188,37 +271,20 @@ export async function runTelegramPhase({ installDir, agentId, nonInteractive = f
   writeEnvFile(installDir, { [botTokenEnv]: token });
   await setDaemonEnv(botTokenEnv, token);
 
-  // Step 2: Chat ID discovery
+  // Step 2: Chat ID discovery via Telegram getUpdates (30s poll)
   let chatId = null;
-  const daemonRunning = isDaemonRunning();
+  const fetchImpl = tui.fetchImpl || globalThis.fetch;
 
-  if (daemonRunning) {
-    // Path A: daemon is running — read from state store
-    console.log(`\n  Open Telegram, find ${cyanImpl(`@${botUsername}`)}, send it any message — then press Enter.`);
-    const since = new Date().toISOString();
-    chatId = await discoverChatIdFromStore(installDir, since);
+  console.log(`  ${dimImpl("Waiting up to 30 seconds for your message...")}`);
+  chatId = await discoverChatIdFromUpdates(token, { timeoutSeconds: 30, fetchImpl });
 
-    if (chatId) {
-      console.log(progressLineImpl("Found you", `chat_id: ${chatId}`));
-    } else {
-      console.log(`  ${yellowImpl("!")} Timed out waiting for a message. Try opening Telegram and sending a message to @${botUsername} first.`);
-      const manual = await promptImpl("Enter chat_id manually (or press Enter to skip)", "");
-      chatId = manual || null;
-    }
+  if (chatId) {
+    console.log(progressLineImpl("Found you", `chat_id: ${chatId}`));
   } else {
-    // Path B: daemon not running — use whoami probe
-    await waitForEnterImpl(`Open Telegram, find ${cyanImpl(`@${botUsername}`)}, send it a message — anything works. Then come back and press Enter.`);
-    const result = await whoami(token);
-    if (result) {
-      chatId = String(result.chatId);
-      const label = result.username ? `chat_id: ${chatId}, @${result.username}` : `chat_id: ${chatId}`;
-      console.log(progressLineImpl("Found you", label));
-    } else {
-      console.log(`  ${yellowImpl("!")} No messages found.`);
-      console.log(`  ${dimImpl("The bot may not have received your message yet.")}`);
-      const manual = await promptImpl("Enter chat_id manually (or press Enter to skip)", "");
-      chatId = manual || null;
-    }
+    console.log(`  ${yellowImpl("!")} No message received within 30 seconds.`);
+    console.log(`  ${dimImpl("You can finish setup now and add your chat_id later.")}`);
+    const manual = await promptImpl("Enter chat_id manually (or press Enter to skip)", "");
+    chatId = manual || null;
   }
 
   const authorizedChatIds = chatId ? [chatId] : [];
@@ -253,6 +319,13 @@ export async function runTelegramPhase({ installDir, agentId, nonInteractive = f
     operatorChatId: chatId || "", authorizedChatIds, defaultAgent: agentId,
   }));
 
+  // Wire delivery.toml so the telegram profile is enabled
+  await patchDeliveryToml(installDir, {
+    chatId: chatId || null,
+    botTokenEnv,
+    chatIdPending: !chatId,
+  });
+
   // Store chat_id in state for later phases (e.g. hatch)
   const result = { configured: true, verified: false, botUsername, botToken: token, operatorChatId: chatId || "" };
 
@@ -260,7 +333,7 @@ export async function runTelegramPhase({ installDir, agentId, nonInteractive = f
 
   // Step 5: Smoke test (with failure handling)
   if (!chatId) {
-    console.log(`  ${yellowImpl("!")} No chat ID — skipping test message.`);
+    console.log(`  ${yellowImpl("!")} No chat ID — skipping test message. You can set it later in config/delivery.toml.`);
     return result;
   }
 

package/src/onboarding/setup-checklist.js

@@ -0,0 +1,108 @@
+import fs from "node:fs";
+import path from "node:path";
+import { parseToml } from "../config/toml-lite.js";
+
+/**
+ * Scans an install directory and returns a map of which capabilities
+ * are configured, pending, or unconfigured.
+ *
+ * @param {string} installDir - Path to the nemoris install directory
+ * @returns {{ identity, provider, telegram, ollama }} checklist
+ */
+export function buildSetupChecklist(installDir) {
+  return {
+    identity: detectIdentity(installDir),
+    provider: detectProvider(installDir),
+    telegram: detectTelegram(installDir),
+    ollama: detectOllama(installDir),
+  };
+}
+
+function detectIdentity(installDir) {
+  try {
+    const agentsDir = path.join(installDir, "config", "agents");
+    if (!fs.existsSync(agentsDir)) return { configured: false };
+    const files = fs.readdirSync(agentsDir).filter((f) => f.endsWith(".toml"));
+    if (files.length === 0) return { configured: false };
+    const agentId = files[0].replace(/\.toml$/, "");
+    const soulDir = path.join(installDir, "config", "identity");
+    const hasSoul = fs.existsSync(soulDir) &&
+      fs.readdirSync(soulDir).some((f) => f.endsWith("-soul.md"));
+    return { configured: hasSoul, agentId };
+  } catch {
+    return { configured: false };
+  }
+}
+
+function detectProvider(installDir) {
+  try {
+    const providersDir = path.join(installDir, "config", "providers");
+    if (!fs.existsSync(providersDir)) return { configured: false };
+    const files = fs.readdirSync(providersDir).filter((f) => f.endsWith(".toml"));
+    if (files.length === 0) return { configured: false };
+    const name = files[0].replace(/\.toml$/, "");
+    return { configured: true, name, count: files.length };
+  } catch {
+    return { configured: false };
+  }
+}
+
+function detectTelegram(installDir) {
+  try {
+    const runtimePath = path.join(installDir, "config", "runtime.toml");
+    if (!fs.existsSync(runtimePath)) return { configured: false };
+    const content = fs.readFileSync(runtimePath, "utf8");
+    const config = parseToml(content);
+    const tg = config.telegram;
+    if (!tg || !tg.bot_token_env) return { configured: false };
+    if (tg.chat_id_pending) return { configured: false, pending: true };
+    if (tg.operator_chat_id) return { configured: true };
+    return { configured: false, pending: true };
+  } catch {
+    return { configured: false };
+  }
+}
+
+function detectOllama(installDir) {
+  try {
+    const providersDir = path.join(installDir, "config", "providers");
+    if (!fs.existsSync(providersDir)) return { configured: false };
+    const ollamaPath = path.join(providersDir, "ollama.toml");
+    return { configured: fs.existsSync(ollamaPath) };
+  } catch {
+    return { configured: false };
+  }
+}
+
+/**
+ * Format checklist for display in `nemoris status`.
+ * @param {object} checklist - from buildSetupChecklist()
+ * @returns {string} formatted text block
+ */
+export function formatSetupChecklist(checklist) {
+  const lines = ["Setup"];
+  const item = (check, label, hint) => {
+    if (check.configured) {
+      lines.push(`  ✅  ${label}`);
+    } else if (check.pending) {
+      lines.push(`  ⚠️   ${label.padEnd(16)} pending auto-discovery`);
+    } else {
+      lines.push(`  ◻   ${label.padEnd(16)} ${hint}`);
+    }
+  };
+
+  const idLabel = checklist.identity.configured
+    ? `Identity       ${checklist.identity.agentId}`
+    : "Identity";
+  item(checklist.identity, idLabel, "nemoris setup");
+
+  const provLabel = checklist.provider.configured
+    ? `Provider       ${checklist.provider.name}${checklist.provider.count > 1 ? ` (+${checklist.provider.count - 1})` : ""}`
+    : "Provider";
+  item(checklist.provider, provLabel, "nemoris setup");
+
+  item(checklist.telegram, "Telegram", "nemoris setup telegram");
+  item(checklist.ollama, "Local models", "nemoris setup ollama");
+
+  return lines.join("\n");
+}

package/src/onboarding/templates.js

@@ -322,6 +322,38 @@ target = "peer_queue"
 `;
 }
 
+// ── Delivery Telegram Patch ──────────────────────────────────────────────────
+
+/**
+ * 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");
+  return `
+default_interactive_profile = "gateway_telegram_main"
+
+[profiles.gateway_telegram_main]
+adapter = "openclaw_cli"
+enabled = true
+channel = "telegram"
+account_id = "default"
+chat_id = "${chatIdValue}"
+bot_token_env = "${botTokenEnv}"
+silent = true
+dry_run = false
+
+[profiles.gateway_preview_main]
+adapter = "openclaw_cli"
+enabled = true
+channel = "telegram"
+account_id = "default"
+chat_id = "${chatIdValue}"
+bot_token_env = "${botTokenEnv}"
+silent = true
+dry_run = true
+`.trim();
+}
+
 // ── Peers ────────────────────────────────────────────────────────────────────
 
 /**

package/src/onboarding/wizard.js

@@ -197,9 +197,259 @@ async function launchChat() {
   });
 }
 
+async function runFastPathWizard({ installDir }) {
+  const prompter = createClackPrompter();
+
+  await prompter.intro("nemoris setup");
+
+  // D2 security gate — brief consent
+  await prompter.note(
+    "This agent will have access to your filesystem and network.\nRun with --security-details for full risk disclosure.",
+    "Security"
+  );
+  const consent = await prompter.confirm({
+    message: "Continue?",
+    initialValue: true,
+  });
+  if (!consent) {
+    await prompter.cancel("Setup cancelled.");
+    return 0;
+  }
+
+  // Existing config? → delegate to update menu (wired in Task 7, for now just exit)
+  const existing = readExistingIdentity(installDir);
+  if (existing.agentId && fs.existsSync(path.join(installDir, "config", "runtime.toml"))) {
+    return runExistingConfigMenu({ installDir, existing, prompter });
+  }
+
+  // Step 1: Identity
+  const userName = await prompter.text({
+    message: "What's your name?",
+    initialValue: process.env.USER || "",
+    validate: (v) => (v.trim() ? undefined : "Name required"),
+  });
+  const agentName = await prompter.text({
+    message: "Name your agent?",
+    initialValue: "Nemo",
+  });
+  const agentId = String(agentName).toLowerCase().replace(/[^a-z0-9-]/g, "-").replace(/-+/g, "-");
+
+  // Step 2: Detect + scaffold (silent)
+  const detection = await detect(installDir);
+  await scaffold({ installDir });
+
+  // Step 3: Provider selection
+  const providerOptions = detectProviderOptions({
+    env: process.env,
+    ollamaResult: detection.ollama ? { ok: true, models: detection.ollama.models } : { ok: false, models: [] },
+  });
+  let provider;
+  if (providerOptions.length === 1) {
+    provider = providerOptions[0].value;
+  } else if (providerOptions.length > 1) {
+    provider = await prompter.select({
+      message: "Pick a provider",
+      options: providerOptions.map((o) => ({
+        value: o.value,
+        label: o.label,
+        hint: o.hint,
+      })),
+    });
+  } else {
+    provider = await prompter.select({
+      message: "Pick a provider",
+      options: [
+        { value: "anthropic", label: "Anthropic" },
+        { value: "openai", label: "OpenAI" },
+        { value: "openrouter", label: "OpenRouter" },
+      ],
+    });
+  }
+
+  // Step 4: Auth + model selection
+  writeIdentity({
+    installDir,
+    userName: userName || process.env.USER || "operator",
+    agentName,
+    agentId,
+    userGoal: "build software",
+  });
+
+  if (provider !== "skip" && provider !== "ollama") {
+    await runAuthPhase(installDir, {
+      tui: createLegacyPromptAdapter(prompter),
+      detectionCache: {
+        rawKeys: detection.apiKeys,
+        ollamaResult: detection.ollama ? { ok: true, models: detection.ollama.models } : { ok: false, models: [] },
+      },
+      providerOrder: [provider],
+    });
+  }
+
+  // Auto-start daemon (best-effort)
+  try {
+    await writeDaemonUnit(installDir);
+    await loadDaemon(installDir);
+  } catch {
+    // Daemon start failure is non-fatal in fast path
+  }
+
+  await prompter.outro(`Agent "${agentName}" is ready.\n  Run: nemoris chat`);
+
+  try {
+    const pkg = JSON.parse(fs.readFileSync(new URL("../../package.json", import.meta.url), "utf8"));
+    writeWizardMetadata(installDir, {
+      lastRunVersion: pkg.version || "",
+      lastRunCommand: "setup",
+      lastRunMode: "fast",
+      lastRunFlow: "interactive",
+      capabilities: { identity: true, provider: true },
+    });
+  } catch {
+    // Non-fatal
+  }
+
+  return 0;
+}
+
+async function runExistingConfigMenu({ installDir, existing, prompter }) {
+  const { buildSetupChecklist } = await import("./setup-checklist.js");
+
+  const action = await prompter.select({
+    message: `Agent "${existing.agentId || existing.agentName}" is already configured.`,
+    options: [
+      { value: "update_provider", label: "Update provider or model" },
+      { value: "add_capability", label: "Add a capability" },
+      { value: "reset", label: "Reset everything" },
+      { value: "exit", label: "Exit" },
+    ],
+  });
+
+  if (action === "update_provider") {
+    return runProviderSubWizard({ installDir });
+  }
+  if (action === "add_capability") {
+    const checklist = buildSetupChecklist(installDir);
+    const unconfigured = [];
+    if (!checklist.telegram.configured) unconfigured.push({ value: "telegram", label: "Telegram" });
+    if (!checklist.ollama.configured) unconfigured.push({ value: "ollama", label: "Local models (Ollama)" });
+    if (unconfigured.length === 0) {
+      await prompter.outro("All capabilities are configured!");
+      return;
+    }
+    const capability = await prompter.select({ message: "What would you like to add?", options: unconfigured });
+    if (capability === "telegram") {
+      return runTelegramPhase({ installDir, agentId: existing.agentId });
+    }
+    if (capability === "ollama") {
+      return runOllamaSubWizard({ installDir });
+    }
+  }
+  if (action === "reset") {
+    const scope = await prompter.select({
+      message: "What should be reset?",
+      options: [
+        { value: "config", label: "Config only" },
+        { value: "config+state", label: "Config + state" },
+        { value: "", label: "Everything" },
+      ],
+    });
+    resetInstallArtifacts(installDir, scope);
+    await prompter.outro("Reset complete. Run: nemoris setup");
+    return;
+  }
+  // exit — do nothing
+  await prompter.outro("No changes made.");
+}
+
+export async function runProviderSubWizard({ installDir }) {
+  const prompter = createClackPrompter();
+  await prompter.intro("Add a provider");
+
+  const detection = await detect(installDir);
+  const options = detectProviderOptions({
+    env: process.env,
+    ollamaResult: detection.ollama ? { ok: true, models: detection.ollama.models } : { ok: false, models: [] },
+  });
+
+  // Filter out already-configured providers
+  const providersDir = path.join(installDir, "config", "providers");
+  const existingProviders = fs.existsSync(providersDir)
+    ? fs.readdirSync(providersDir).filter((f) => f.endsWith(".toml")).map((f) => f.replace(/\.toml$/, ""))
+    : [];
+  const filtered = options.filter((o) => !existingProviders.includes(o.value));
+
+  if (filtered.length === 0) {
+    await prompter.outro("All detected providers are already configured.");
+    return;
+  }
+
+  const provider = await prompter.select({ message: "Which provider?", options: filtered });
+
+  // Reuse existing auth phase
+  if (provider !== "skip" && provider !== "ollama") {
+    await runAuthPhase(installDir, {
+      tui: createLegacyPromptAdapter(prompter),
+      detectionCache: {
+        rawKeys: detection.apiKeys,
+        ollamaResult: detection.ollama ? { ok: true, models: detection.ollama.models } : { ok: false, models: [] },
+      },
+      providerOrder: [provider],
+    });
+  }
+
+  try {
+    const pkg = JSON.parse(fs.readFileSync(new URL("../../package.json", import.meta.url), "utf8"));
+    writeWizardMetadata(installDir, {
+      lastRunVersion: pkg.version || "",
+      lastRunCommand: "setup provider",
+      lastRunMode: "fast",
+      lastRunFlow: "interactive",
+      capabilities: { [`provider_${provider}`]: true },
+    });
+  } catch {
+    // Non-fatal
+  }
+
+  await prompter.outro(`${provider} configured. Run: nemoris status`);
+}
+
+export async function runOllamaSubWizard({ installDir }) {
+  const prompter = createClackPrompter();
+  await prompter.intro("Add local models (Ollama)");
+
+  await runOllamaPhase({ installDir });
+
+  try {
+    const pkg = JSON.parse(fs.readFileSync(new URL("../../package.json", import.meta.url), "utf8"));
+    writeWizardMetadata(installDir, {
+      lastRunVersion: pkg.version || "",
+      lastRunCommand: "setup ollama",
+      lastRunMode: "fast",
+      lastRunFlow: "interactive",
+      capabilities: { ollama: true },
+    });
+  } catch {
+    // Non-fatal
+  }
+
+  await prompter.outro("Ollama configured. Run: nemoris status");
+}
+
 async function runInteractiveWizard({
   installDir,
   flowOverride = null,
+  manual = false,
+}) {
+  if (manual) {
+    return runManualWizard({ installDir, flowOverride });
+  }
+  return runFastPathWizard({ installDir });
+}
+
+async function runManualWizard({
+  installDir,
+  flowOverride = null,
 }) {
   const prompter = createClackPrompter();
 
@@ -587,6 +837,7 @@ export async function runWizard({
   nonInteractive = false,
   acceptRisk = false,
   flow = null,
+  manual = false,
   anthropicKey = null,
   openaiKey = null,
   openrouterKey = null,
@@ -609,6 +860,7 @@ export async function runWizard({
       : await runInteractiveWizard({
           installDir,
           flowOverride: flow,
+          manual,
         });
   } catch (error) {
     if (error instanceof SetupCancelledError) {

package/src/runtime/status-aggregator.js

@@ -7,6 +7,7 @@ import { PeerRegistry } from "./peer-registry.js";
 import { SchedulerStateStore } from "./scheduler-state.js";
 import { computeNextRun } from "./schedule.js";
 import { ProviderRegistry } from "../providers/registry.js";
+import { buildSetupChecklist, formatSetupChecklist } from "../onboarding/setup-checklist.js";
 
 function _safeCount(arr) {
   return Array.isArray(arr) ? arr.length : 0;
@@ -245,7 +246,8 @@ export async function buildRuntimeStatus(options = {}) {
     providers,
     delivery: deliveryStatus,
     peers,
-    runtime: runtimeStats
+    runtime: runtimeStats,
+    _installDir: projectRoot
   };
 }
 
@@ -279,6 +281,15 @@ export function formatRuntimeStatus(status) {
   }
   lines.push("");
 
+  if (status._installDir) {
+    const checklist = buildSetupChecklist(status._installDir);
+    const allConfigured = Object.values(checklist).every((c) => c.configured);
+    if (!allConfigured) {
+      lines.push(formatSetupChecklist(checklist));
+      lines.push("");
+    }
+  }
+
   // Agents
   lines.push(`--- Agents (${status.agents.length}) ---`);
   for (const agent of status.agents) {

package/src/runtime/telegram-inbound.js

@@ -466,12 +466,23 @@ export async function whoami(botToken, { fetchImpl = globalThis.fetch, webhookUr
  *
  * Returns a stop() function that cleanly terminates the loop.
  */
-export function startTelegramPolling({ botToken, handler, logger = console, fetchImpl = globalThis.fetch }) {
+export function startTelegramPolling({ botToken, handler, logger = console, fetchImpl = globalThis.fetch, projectRoot = null }) {
   const api = (method) => `https://api.telegram.org/bot${botToken}/${method}`;
   let running = true;
   let offset = 0;
   const stateStore = handler?.store || null;
 
+  // One-shot flag: true when runtime.toml has chat_id_pending = true
+  let pendingChatIdDiscovery = false;
+  if (projectRoot) {
+    try {
+      const rtp = path.join(projectRoot, "config", "runtime.toml");
+      if (fs.existsSync(rtp) && fs.readFileSync(rtp, "utf8").includes("chat_id_pending = true")) {
+        pendingChatIdDiscovery = true;
+      }
+    } catch (_) { /* ignore — best effort */ }
+  }
+
   const persistOffset = async (nextOffset) => {
     if (!stateStore || typeof stateStore.setMeta !== "function") {
       return;
@@ -529,6 +540,26 @@ export function startTelegramPolling({ botToken, handler, logger = console, fetc
             const chatId = update?.message?.chat?.id;
             const messageId = update?.message?.message_id;
 
+            // Auto-discover chat_id when onboarding left chat_id_pending = true
+            if (chatId && pendingChatIdDiscovery) {
+              try {
+                const { resolvePendingChatId } = await import("../onboarding/phases/telegram.js");
+                resolvePendingChatId(projectRoot, String(chatId));
+                pendingChatIdDiscovery = false;
+                logger.info(JSON.stringify({
+                  service: "telegram_polling",
+                  event: "chat_id_auto_discovered",
+                  chatId: String(chatId),
+                }));
+              } catch (err) {
+                logger.error(JSON.stringify({
+                  service: "telegram_polling",
+                  event: "chat_id_discovery_error",
+                  error: err.message,
+                }));
+              }
+            }
+
             // React 👀 on enqueue (job accepted, processing starting)
             if (result?.action === "enqueued" && chatId && messageId) {
               fetchImpl(`https://api.telegram.org/bot${botToken}/setMessageReaction`, {