nemoris 0.1.6 → 0.1.9

package/package.json

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

package/src/cli/runtime-control.js

@@ -487,24 +487,49 @@ export async function cleanupOrphanedDaemonProcesses({
 
 export async function startDirectDaemon({
   projectRoot,
-  cliEntryPath = path.join(projectRoot, "src", "cli.js"),
+  cliEntryPath,
   fsImpl = fs,
   spawnImpl = spawn,
   processImpl = process,
 } = {}) {
+  // Resolve CLI entry: explicit path > source repo > which nemoris > package __dirname
+  if (!cliEntryPath) {
+    const srcCliPath = path.join(projectRoot, "src", "cli.js");
+    if (fsImpl.existsSync(srcCliPath)) {
+      cliEntryPath = srcCliPath;
+    } else {
+      try {
+        const { execFileSync } = await import("node:child_process");
+        const whichOut = execFileSync("which", ["nemoris"], { encoding: "utf8", timeout: 3000 }).trim();
+        if (whichOut) {
+          cliEntryPath = whichOut;
+        }
+      } catch { /* which not available */ }
+    }
+    if (!cliEntryPath) {
+      // Fallback: resolve from this module's own package
+      const __dirname = path.dirname(new URL(import.meta.url).pathname);
+      cliEntryPath = path.join(__dirname, "..", "cli.js");
+    }
+  }
   const { stateDir, pidFile, stdoutLog, stderrLog } = getDaemonPaths(projectRoot);
   fsImpl.mkdirSync(stateDir, { recursive: true });
   const stdoutFd = fsImpl.openSync(stdoutLog, "a");
   const stderrFd = fsImpl.openSync(stderrLog, "a");
 
   try {
+    // Only set NEMORIS_INSTALL_DIR for the child when the path is a clean
+    // data directory. If it's the source repo (has package.json), the child
+    // will detect it via CWD detection instead — avoids the source repo guard.
+    const childEnv = { ...processImpl.env };
+    const looksLikeSourceRepo = fsImpl.existsSync(path.join(projectRoot, "package.json"));
+    if (!looksLikeSourceRepo) {
+      childEnv.NEMORIS_INSTALL_DIR = projectRoot;
+    }
     const child = spawnImpl(processImpl.execPath, [cliEntryPath, "serve-daemon", "live"], {
       cwd: projectRoot,
       detached: true,
-      env: {
-        ...processImpl.env,
-        NEMORIS_INSTALL_DIR: projectRoot,
-      },
+      env: childEnv,
       stdio: ["ignore", stdoutFd, stderrFd],
     });
     child.unref?.();

package/src/cli-main.js

@@ -2450,7 +2450,17 @@ export async function main(argv = process.argv) {
     const { pidFile } = getDaemonPaths(installDir);
     const trackedPid = readTrackedPid(pidFile);
     const hasTrackedDaemon = isPidRunning(trackedPid);
-    const runningPids = hasTrackedDaemon ? [trackedPid] : await listServeDaemonPids();
+    let runningPids = hasTrackedDaemon ? [trackedPid] : await listServeDaemonPids();
+    // Fallback: check launchd/systemd service if no PID found
+    if (runningPids.length === 0) {
+      try {
+        const { isDaemonRunning } = await import("./onboarding/platform.js");
+        if (isDaemonRunning()) {
+          // Service is running but PID file is missing — proceed anyway
+          runningPids = [0];
+        }
+      } catch { /* platform check unavailable */ }
+    }
     if (runningPids.length === 0) {
       writeOutput(process.stderr, "Daemon not running. Start with: nemoris start");
       process.exitCode = 1;
@@ -2735,13 +2745,27 @@ export async function main(argv = process.argv) {
     });
   } else if (command === "doctor") {
     const { runDoctor, formatDoctorReport } = await import("./onboarding/doctor.js");
-    const results = await runDoctor(resolveRuntimeInstallDir());
+    const doctorInstallDir = resolveRuntimeInstallDir();
+    const results = await runDoctor(doctorInstallDir);
     const json = rest.includes("--json");
+    const fix = rest.includes("--fix");
     if (json) {
       console.log(JSON.stringify(results, null, 2));
     } else {
       console.log(formatDoctorReport(results));
     }
+    // Auto-repair: clean stale PID file
+    if (fix && results.daemon?.stalePidFile) {
+      const { pidFile } = getDaemonPaths(doctorInstallDir);
+      try {
+        fs.unlinkSync(pidFile);
+        console.log("\n  \u2705  Cleaned stale PID file. Run: nemoris start");
+      } catch {
+        console.log("\n  \u274c  Could not remove stale PID file.");
+      }
+    } else if (!fix && results.daemon?.stalePidFile) {
+      console.log("\n  Tip: run nemoris doctor --fix to clean the stale PID file.");
+    }
     return results.exitCode;
   } else if (command === "battle") {
     const { runBattle, parseBattleFlags } = await import("./battle.js");

package/src/onboarding/phases/auth.js

@@ -78,37 +78,66 @@ const PROVIDER_MODEL_PRESETS = {
     },
   ],
   openrouter: [
-    {
-      key: "haiku",
-      id: "openrouter/anthropic/claude-haiku-4-5",
-      label: "Claude Haiku 4.5",
-      description: "Lowest-cost OpenRouter default.",
-    },
+    // Anthropic via OpenRouter
     {
       key: "sonnet",
       id: "openrouter/anthropic/claude-sonnet-4-6",
-      label: "Claude Sonnet 4.6",
+      label: "Sonnet 4.6 (Anthropic)",
       description: "Strong general-purpose default.",
+      group: "Anthropic",
     },
     {
-      key: "gpt4o",
-      id: "openrouter/openai/gpt-4o",
-      label: "GPT-4o",
-      description: "Fast multimodal OpenAI route through OpenRouter.",
+      key: "haiku",
+      id: "openrouter/anthropic/claude-haiku-4-5",
+      label: "Haiku 4.5 (Anthropic)",
+      description: "Fastest and cheapest Anthropic model.",
+      group: "Anthropic",
     },
     {
       key: "opus",
       id: "openrouter/anthropic/claude-opus-4-6",
-      label: "Claude Opus 4.6",
+      label: "Opus 4.6 (Anthropic)",
       description: "Highest quality. Use when Sonnet isn't enough.",
+      group: "Anthropic",
+    },
+    // OpenAI via OpenRouter
+    {
+      key: "gpt4o",
+      id: "openrouter/openai/gpt-4o",
+      label: "GPT-4o (OpenAI)",
+      description: "Fast multimodal OpenAI model.",
+      group: "OpenAI",
+    },
+    {
+      key: "gpt4omini",
+      id: "openrouter/openai/gpt-4o-mini",
+      label: "GPT-4o mini (OpenAI)",
+      description: "Cheapest OpenAI option.",
+      group: "OpenAI",
+    },
+    // Google via OpenRouter
+    {
+      key: "gemini31pro",
+      id: "openrouter/google/gemini-3.1-pro",
+      label: "Gemini 3.1 Pro (Google)",
+      description: "Frontier Google model, strong benchmarks.",
+      group: "Google",
+    },
+    // Meta via OpenRouter
+    {
+      key: "llama4scout",
+      id: "openrouter/meta-llama/llama-4-scout",
+      label: "Llama 4 Scout (Meta)",
+      description: "Open-weight Meta model.",
+      group: "Meta",
     },
   ],
   openai: [
     {
-      key: "gpt41",
-      id: "openai-codex/gpt-4.1",
-      label: "GPT-4.1",
-      description: "Latest large-context default.",
+      key: "gpt54",
+      id: "openai-codex/gpt-5.4",
+      label: "GPT-5.4",
+      description: "Latest flagship model.",
     },
     {
       key: "gpt4o",
@@ -116,18 +145,18 @@ const PROVIDER_MODEL_PRESETS = {
       label: "GPT-4o",
       description: "Fast multimodal fallback.",
     },
+    {
+      key: "gpt4omini",
+      id: "openai-codex/gpt-4o-mini",
+      label: "GPT-4o mini",
+      description: "Cheapest and fastest.",
+    },
     {
       key: "o4mini",
       id: "openai-codex/o4-mini",
       label: "o4-mini",
       description: "Efficient reasoning path.",
     },
-    {
-      key: "o3",
-      id: "openai-codex/o3",
-      label: "o3",
-      description: "Most capable reasoning option.",
-    },
   ],
 };
 
@@ -275,9 +304,26 @@ async function buildProviderSelectionOptions(provider, key, { fetchImpl = global
     : curated;
   const curatedIds = new Set(curatedAvailable.map((item) => item.id));
 
-  // Remaining fetched models not already shown as curated
+  // Remaining fetched models not already shown as curated.
+  // For providers with huge catalogs (OpenRouter: 1000+ models), filter to
+  // well-known vendors and cap the list to avoid an unusable wall of options.
+  const KNOWN_VENDORS = new Set([
+    "anthropic", "openai", "google", "meta-llama", "mistralai",
+    "deepseek", "cohere", "qwen", "microsoft", "nvidia",
+  ]);
+  const MAX_EXTRA = 20;
   const extra = fetchedModels
-    .filter((m) => !curatedIds.has(m.id))
+    .filter((m) => {
+      if (curatedIds.has(m.id)) return false;
+      // For large catalogs, only show models from known vendors
+      if (fetchedModels.length > 50) {
+        const rawId = m.id.replace(/^openrouter\//, "").replace(/^openai-codex\//, "").replace(/^anthropic\//, "");
+        const vendor = rawId.split("/")[0];
+        return KNOWN_VENDORS.has(vendor);
+      }
+      return true;
+    })
+    .slice(0, MAX_EXTRA)
     .map((m) => {
       const displayId = m.id
         .replace(/^openrouter\//, "")
@@ -288,25 +334,49 @@ async function buildProviderSelectionOptions(provider, key, { fetchImpl = global
       return { value: m.id, label: displayId, description: desc };
     });
 
+  // Detect new models matching known patterns that aren't in the curated list
+  const NEW_MODEL_PATTERNS = [
+    /claude-.*-[5-9]-/,      // future Claude major versions
+    /gpt-[6-9]/,             // future GPT major versions
+    /gpt-5\.[5-9]/,          // future GPT-5.x minor versions
+    /gemini-[4-9]/,          // future Gemini major versions
+    /llama-[5-9]/,           // future Llama major versions
+  ];
+  const newModels = fetchedModels
+    .filter((m) => {
+      if (curatedIds.has(m.id)) return false;
+      const rawId = stripProviderPrefix(provider, m.id);
+      return NEW_MODEL_PATTERNS.some((p) => p.test(rawId));
+    })
+    .map((m) => {
+      const displayId = stripProviderPrefix(provider, m.id);
+      const ctxStr = formatContextWindow(m.contextWindow);
+      const desc = ctxStr ? `New model \u00b7 ${ctxStr}` : "New model";
+      return { value: m.id, label: `\u2605 ${m.name || displayId}`, description: desc };
+    });
+
   const options = [
+    ...newModels,
     ...curatedAvailable.map((item) => {
       const fetched = fetchedMap.get(item.id);
       const ctxStr = fetched ? formatContextWindow(fetched.contextWindow) : "";
       const desc = ctxStr ? `${item.description} \u00b7 ${ctxStr}` : item.description;
       return { value: item.id, label: item.label, description: desc };
     }),
-    ...extra,
+    { value: "__show_all__", label: "\u2193 Show all models", description: `Browse all ${fetchedModels.length} models from provider.` },
     { value: "__custom__", label: "Enter a different model name...", description: "Use a specific model id not shown in the list." },
   ];
 
-  return { options, fetchedModels };
+  // Extra models only shown when "Show all" is selected
+  return { options, fetchedModels, extra };
 }
 
 async function promptForProviderModels(provider, key, tui, { fetchImpl = globalThis.fetch } = {}) {
   const { select, prompt, dim, cyan } = tui;
   if (!select) return { chosen: [], fetchedModels: [] };
 
-  const { options, fetchedModels } = await buildProviderSelectionOptions(provider, key, { fetchImpl });
+  const { options, fetchedModels, extra } = await buildProviderSelectionOptions(provider, key, { fetchImpl });
+  let activeOptions = options;
   const chosen = [];
   const manualOptionValue = "__custom__";
   const defaultModelValue = options.find((item) => !String(item.value).startsWith("__"))?.value || "";
@@ -315,7 +385,7 @@ async function promptForProviderModels(provider, key, tui, { fetchImpl = globalT
   console.log(`  ${dim("Pick up to three models. The first is your default. The others are fallbacks when the default is slow or unavailable.")}`);
 
   while (chosen.length < 3) {
-    const remaining = options.filter((item) => !chosen.includes(item.value));
+    const remaining = activeOptions.filter((item) => !chosen.includes(item.value));
     const pickerOptions = remaining.map((item) => ({
       label: item.label,
       value: item.value,
@@ -342,6 +412,16 @@ async function promptForProviderModels(provider, key, tui, { fetchImpl = globalT
       break;
     }
 
+    if (picked === "__show_all__") {
+      // Expand to full filtered list + custom entry
+      activeOptions = [
+        ...activeOptions.filter((o) => !o.value.startsWith("__")),
+        ...(extra || []),
+        { value: "__custom__", label: "Enter a different model name...", description: "Use a specific model id not shown in the list." },
+      ];
+      continue;
+    }
+
     let modelId = picked;
     if (picked === manualOptionValue) {
       const custom = await prompt("Model id", stripProviderPrefix(provider, defaultModelValue));

package/src/onboarding/platform.js

@@ -354,11 +354,18 @@ export function isDaemonRunning() {
 
   if (platform === "darwin") {
     try {
-      const { status } = spawnSync(
+      const { status, stdout } = spawnSync(
         "launchctl", ["list", "ai.nemoris.daemon"],
-        { timeout: 3000, stdio: "pipe" },
+        { timeout: 3000, stdio: "pipe", encoding: "utf8" },
       );
-      return status === 0;
+      if (status !== 0) return false;
+      // Service is loaded — verify the process is actually alive.
+      // launchctl list <label> includes "PID" = <number> when running.
+      const pidMatch = String(stdout || "").match(/"PID"\s*=\s*(\d+)/);
+      if (!pidMatch) return false;
+      const pid = Number.parseInt(pidMatch[1], 10);
+      if (!pid || pid <= 0) return false;
+      try { process.kill(pid, 0); return true; } catch { return false; }
     } catch {
       return false;
     }

package/src/onboarding/setup-checklist.js

@@ -41,7 +41,18 @@ function detectProvider(installDir) {
     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 };
+    // Read primary model from the first provider config
+    let primaryModel = "";
+    try {
+      const content = fs.readFileSync(path.join(providersDir, files[0]), "utf8");
+      const config = parseToml(content);
+      const models = config.models || {};
+      const firstModelKey = Object.keys(models)[0];
+      if (firstModelKey && models[firstModelKey]?.id) {
+        primaryModel = models[firstModelKey].id;
+      }
+    } catch { /* non-fatal */ }
+    return { configured: true, name, count: files.length, primaryModel };
   } catch {
     return { configured: false };
   }
@@ -96,9 +107,12 @@ export function formatSetupChecklist(checklist) {
     : "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";
+  let provLabel = "Provider";
+  if (checklist.provider.configured) {
+    const model = checklist.provider.primaryModel || "";
+    const modelSuffix = model ? ` \u00b7 ${model}` : "";
+    provLabel = `Provider       ${checklist.provider.name}${modelSuffix}`;
+  }
   item(checklist.provider, provLabel, "nemoris setup");
 
   item(checklist.telegram, "Telegram", "nemoris setup telegram");

package/src/onboarding/wizard.js

@@ -200,6 +200,20 @@ async function launchChat() {
 async function runFastPathWizard({ installDir }) {
   const prompter = createClackPrompter();
 
+  // ASCII banner
+  const BRAND = "\x1b[38;2;45;212;191m";
+  const RESET = "\x1b[0m";
+  console.log([
+    "",
+    `${BRAND}  ███╗   ██╗███████╗███╗   ███╗ ██████╗ ██████╗ ██╗███████╗${RESET}`,
+    `${BRAND}  ████╗  ██║██╔════╝████╗ ████║██╔═══██╗██╔══██╗██║██╔════╝${RESET}`,
+    `${BRAND}  ██╔██╗ ██║█████╗  ██╔████╔██║██║   ██║██████╔╝██║███████╗${RESET}`,
+    `${BRAND}  ██║╚██╗██║██╔══╝  ██║╚██╔╝██║██║   ██║██╔══██╗██║╚════██║${RESET}`,
+    `${BRAND}  ██║ ╚████║███████╗██║ ╚═╝ ██║╚██████╔╝██║  ██║██║███████║${RESET}`,
+    `${BRAND}  ╚═╝  ╚═══╝╚══════╝╚═╝     ╚═╝ ╚═════╝ ╚═╝  ╚═╝╚═╝╚══════╝${RESET}`,
+    "",
+  ].join("\n"));
+
   await prompter.intro("nemoris setup");
 
   // D2 security gate — brief consent
@@ -266,6 +280,20 @@ async function runFastPathWizard({ installDir }) {
     });
   }
 
+  // Ask consent to use detected API key
+  const detectedKey = detection.apiKeys?.[provider];
+  if (detectedKey) {
+    const masked = detectedKey.slice(0, 6) + "..." + detectedKey.slice(-4);
+    const useDetected = await prompter.confirm({
+      message: `Found ${provider} key in env (${masked}) — use it?`,
+      initialValue: true,
+    });
+    if (!useDetected) {
+      // Clear detected key so auth phase will prompt for a new one
+      delete detection.apiKeys[provider];
+    }
+  }
+
   // Step 4: Auth + model selection
   writeIdentity({
     installDir,
@@ -286,24 +314,58 @@ async function runFastPathWizard({ installDir }) {
     });
   }
 
-  // Auto-start daemon (best-effort)
-  try {
-    await writeDaemonUnit(installDir);
-    await loadDaemon(installDir);
-  } catch {
-    // Daemon start failure is non-fatal in fast path
+  // 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
+  if (!checklist.telegram.configured) {
+    const wantTelegram = await prompter.confirm({
+      message: "Set up Telegram now?",
+      initialValue: false,
+    });
+    if (wantTelegram) {
+      await runTelegramPhase({
+        installDir,
+        agentId,
+      });
+    }
   }
 
-  await prompter.outro(`Agent "${agentName}" is ready.\n  Run: nemoris chat`);
+  await prompter.outro("Run: nemoris start");
 
   try {
     const pkg = JSON.parse(fs.readFileSync(new URL("../../package.json", import.meta.url), "utf8"));
+    const caps = { identity: true, provider: true };
+    // Re-check telegram after possible inline setup
+    const updatedChecklist = buildSetupChecklist(installDir);
+    if (updatedChecklist.telegram.configured || updatedChecklist.telegram.pending) {
+      caps.telegram = true;
+    }
     writeWizardMetadata(installDir, {
       lastRunVersion: pkg.version || "",
       lastRunCommand: "setup",
       lastRunMode: "fast",
       lastRunFlow: "interactive",
-      capabilities: { identity: true, provider: true },
+      capabilities: caps,
     });
   } catch {
     // Non-fatal

package/src/utils/env-loader.js

@@ -1,5 +1,33 @@
+import fs from "node:fs";
 import path from "node:path";
+import os from "node:os";
 
+/**
+ * Resolve the .env file path. Priority:
+ * 1. NEMORIS_INSTALL_DIR/.env (explicit data dir)
+ * 2. CWD/.env (dev mode — running from source repo)
+ * 3. ~/.nemoris-data/.env (default install dir)
+ * 4. package dir/.env (legacy fallback)
+ */
 export function resolveEnvPath(srcDir) {
+  // 1. Explicit install dir
+  if (process.env.NEMORIS_INSTALL_DIR) {
+    return path.join(process.env.NEMORIS_INSTALL_DIR, ".env");
+  }
+
+  // 2. Dev mode — CWD is source repo
+  const cwd = process.cwd();
+  if (fs.existsSync(path.join(cwd, "package.json")) &&
+      fs.existsSync(path.join(cwd, "src", "cli.js"))) {
+    return path.join(cwd, ".env");
+  }
+
+  // 3. Default data dir
+  const defaultEnv = path.join(os.homedir(), ".nemoris-data", ".env");
+  if (fs.existsSync(defaultEnv)) {
+    return defaultEnv;
+  }
+
+  // 4. Legacy: package dir
   return path.resolve(srcDir, "..", ".env");
 }