vault-cortex 0.9.0 → 0.10.1-beta.48

package/README.md

@@ -15,7 +15,7 @@ and data files — see the
 The server runs as a Docker container; this CLI scaffolds the config and
 manages the container so you don't have to.
 
-![npx vault-cortex init — the interactive setup wizard picks a mode, finds your vault, offers the optional settings, generates the config, and starts the server](https://raw.githubusercontent.com/aliasunder/vault-cortex/main/assets/demo-cli-init.gif)
+![npx vault-cortex@latest init — the interactive setup wizard picks a mode, finds your vault, offers the optional settings, generates the config, and starts the server](https://raw.githubusercontent.com/aliasunder/vault-cortex/main/assets/demo-cli-init.gif)
 
 ## Commands
 
@@ -25,6 +25,8 @@ manages the container so you don't have to.
   restart to apply them
 - [`upgrade`](#upgrade) — pull the latest image and re-create the container;
   your data stays
+- [`start`](#start) — start the server with your saved settings, e.g. after
+  `down`
 - [`restart`](#restart) — re-create the container so your `.env` edits take
   effect; no image pull
 - [`logs`](#logs) — show the server's logs, live or after the fact
@@ -32,7 +34,7 @@ manages the container so you don't have to.
 - [`get-sync-token`](#get-sync-token) — generate an Obsidian Sync auth token
   for remote setups
 
-Run `npx vault-cortex <command> --help` for all flags.
+Run `npx vault-cortex@latest <command> --help` for all flags.
 
 ## init
 
@@ -47,18 +49,19 @@ What it does:
    - **Remote** — a VPS with [Obsidian Sync](https://obsidian.md/sync),
      reachable from any device
 2. Offers the most common optional settings — memory layer and folder,
-   file tools, semantic search, port, timezone (plus sync direction for
-   remote) — press enter to keep the defaults, or pick the ones you want to
-   change. Skipped when the target directory already has a `.env` (use
-   [`configure`](#configure) instead)
+   daily notes folder and format, file tools, semantic search, port,
+   timezone (plus sync direction for remote) — press enter to keep the
+   defaults, or pick the ones you want to change
 3. Generates a `.env` file with a securely generated `MCP_AUTH_TOKEN`
 4. Optionally starts the container and waits for the health check
 5. Prints your connection details — the MCP URL, your auth token, and how to
    connect your client
 
-Existing files are never overwritten without asking. During a remote setup,
-init offers to run [`get-sync-token`](#get-sync-token) for you when Docker is
-available.
+Re-running init where a setup already exists asks first — declining leaves
+everything unchanged and points you at [`configure`](#configure), the right
+tool for changing settings in place. Existing files are never overwritten
+without asking. During a remote setup, init offers to run
+[`get-sync-token`](#get-sync-token) for you when Docker is available.
 
 Flags:
 
@@ -82,11 +85,13 @@ Change optional settings on an existing setup:
 npx vault-cortex@latest configure
 ```
 
-Shows the same settings chooser as [`init`](#init) — memory layer and
-folder, file tools, semantic search, port, timezone (plus sync direction
-for remote) — pre-filled with your current values, saves your picks to
-`.env`, and offers to restart the container so they take effect. Settings not in the chooser
-live in `.env` too: edit the value there, then run [`restart`](#restart).
+Shows the same settings chooser as [`init`](#init), pre-filled with your
+current values, saves your picks to `.env`, and offers to restart the
+container so they take effect.
+
+Settings not in the chooser live in `.env` too: edit the value there, then
+run [`restart`](#restart). That's also how you clear a daily notes setting
+back to your vault's own configuration — comment out or delete its line.
 
 Use `--dir <path>` if your config isn't in `./vault-cortex`.
 
@@ -115,6 +120,22 @@ include Compose files you can use directly. If you set up with Compose, stick
 with Compose for updates too (`docker compose pull && docker compose up -d`)
 — the CLI and Compose manage the container independently.
 
+## start
+
+Start the server with your saved settings and verify health:
+
+```bash
+npx vault-cortex@latest start
+```
+
+This is the command the CLI's own guidance points to whenever the server
+isn't running — after [`down`](#down), or an `init` where the server wasn't
+started. It's the same cycle as [`restart`](#restart) under the name you'd
+look for: any existing container is replaced, and Docker pulls the server
+image automatically on a first start.
+
+Use `--dir <path>` if your config isn't in `./vault-cortex`.
+
 ## restart
 
 Re-create the container from your `.env` and verify health:
@@ -125,7 +146,7 @@ npx vault-cortex@latest restart
 
 Use it after editing `.env` — settings are only read when the container is
 created, so a plain `docker restart` won't pick them up, but this will. Unlike
-[`upgrade`](#upgrade), it never pulls a new image: you get the same server
+[`upgrade`](#upgrade), it never updates the server image: you get the same
 version back, with your current settings applied.
 
 Use `--dir <path>` if your config isn't in `./vault-cortex`.
@@ -159,7 +180,7 @@ npx vault-cortex@latest down
 
 Safe by design: your vault, search index, and `.env` settings all live
 outside the container, so nothing is lost. Start again any time with
-[`restart`](#restart). Running `down` when nothing is running is fine — it
+[`start`](#start). Running `down` when nothing is running is fine — it
 just tells you there's nothing to stop.
 
 Use `--dir <path>` if your config isn't in `./vault-cortex`.
@@ -190,7 +211,8 @@ is available.
 - Node.js >= 20.12 (only for this CLI — the server itself runs in Docker)
 - [Docker](https://docs.docker.com/get-docker/) or a Docker-compatible
   runtime (e.g. OrbStack, Colima, Podman) to run the server — the CLI
-  manages the container through the `docker` command
+  manages the container through the `docker` command (on Linux, see
+  [Docker Engine](https://docs.docker.com/engine/install/))
 
 ## Docs
 

package/dist/configure.js

@@ -20,7 +20,10 @@ export const runConfigure = async (flags, deps) => {
     const envContent = readFileSync(envFilePath, "utf8");
     const pickedOverrides = await askOptionalSettings({ mode, envContent }, prompts);
     if (Object.keys(pickedOverrides).length === 0) {
-        prompts.log("No settings selected — nothing changed.");
+        // Covers both empty-overrides paths: nothing picked in the chooser, and
+        // picked-but-kept (an optionalText prompt left blank logs its own
+        // "Kept the current value" line, which this must not contradict).
+        prompts.log("No changes to apply.");
         prompts.outro("Done.");
         return 0;
     }
@@ -34,9 +37,15 @@ export const runConfigure = async (flags, deps) => {
     if (pickedOverrides.PORT && !overrides.PUBLIC_URL && currentPublicUrl) {
         prompts.warn(`PORT changed — make sure PUBLIC_URL (${currentPublicUrl}) still reaches the server.`);
     }
-    const restartHint = `Apply the new settings with: npx vault-cortex restart --dir "${targetDir}"`;
-    if (!docker.isDaemonRunning()) {
-        prompts.warn(`Container runtime not running — settings saved.\n${restartHint}`);
+    const restartHint = `Apply the new settings with: npx vault-cortex@latest restart --dir "${targetDir}"`;
+    const daemonStatus = docker.daemonStatus();
+    if (daemonStatus !== "running") {
+        // Settings are already saved — the runtime state only affects the restart
+        // offer, so both non-running states degrade to the hint; restart itself
+        // prints the full install/start guidance when run.
+        prompts.warn(daemonStatus === "not-installed"
+            ? `No container runtime found — settings saved.\n${restartHint}`
+            : `Container runtime not running — settings saved.\n${restartHint}`);
         prompts.outro("Done.");
         return 0;
     }
@@ -52,7 +61,7 @@ export const runConfigure = async (flags, deps) => {
     if (!deployment) {
         // The edit already succeeded — don't let the failed restart read as a
         // failed configure.
-        prompts.warn(`The restart did not run — your settings are saved. Fix the issue above, then apply them with: npx vault-cortex restart --dir "${targetDir}"`);
+        prompts.warn(`The restart did not run — your settings are saved. Fix the issue above, then apply them with: npx vault-cortex@latest restart --dir "${targetDir}"`);
         return 1;
     }
     const exitCode = await recreateContainer({ deployment, healthTimeoutMs: deps.healthTimeoutMs }, { prompts, docker, fetchFn });

package/dist/docker.js

@@ -107,8 +107,23 @@ export const buildDockerLogsArgs = (params) => {
         CONTAINER_NAME,
     ];
 };
+/**
+ * Classifies a `docker info` spawnSync result. ENOENT on the spawn itself
+ * means the `docker` binary is absent (not installed); any other failure —
+ * non-zero exit, timeout, signal kill — means the binary exists but the
+ * daemon isn't answering. `status` alone can't make that call: it is null
+ * for ENOENT *and* for timeouts, so the split keys on the error code.
+ */
+export const classifyDaemonStatus = (spawnResult) => {
+    if (spawnResult.status === 0)
+        return "running";
+    const spawnErrorCode = spawnResult.error && "code" in spawnResult.error
+        ? spawnResult.error.code
+        : undefined;
+    return spawnErrorCode === "ENOENT" ? "not-installed" : "not-running";
+};
 export const createDockerRunner = () => ({
-    isDaemonRunning: () => spawnSync("docker", ["info"], { timeout: 5_000 }).status === 0,
+    daemonStatus: () => classifyDaemonStatus(spawnSync("docker", ["info"], { timeout: 5_000 })),
     // stdout is discarded: `docker run -d` prints only the container ID there,
     // which lands as a raw hex line between the wizard's prompts. stderr stays
     // inherited — image-pull progress and error output print live, which the
@@ -154,6 +169,28 @@ export const createDockerRunner = () => ({
         gid: process.getgid?.(),
     }), { stdio: "inherit" }).status === 0,
 });
+/** Default bound on a single health request (shared by probe and poll). */
+const PROBE_TIMEOUT_MS = 10_000;
+/**
+ * One-shot health probe: true on an HTTP 2xx, false on any error, non-2xx,
+ * or timeout — false IS the handled outcome for a boolean probe, so the
+ * catch maps rather than logs. Unlike the localhost poll target (which fails
+ * fast with ECONNREFUSED), a public URL behind a dropped firewall rule can
+ * black-hole the TCP handshake for minutes — the abort timeout bounds every
+ * caller.
+ */
+export const probeHealth = async (params, fetchFn) => {
+    const { url, timeoutMs = PROBE_TIMEOUT_MS } = params;
+    try {
+        const response = await fetchFn(url, {
+            signal: AbortSignal.timeout(timeoutMs),
+        });
+        return response.ok;
+    }
+    catch {
+        return false;
+    }
+};
 /**
  * Polls the health endpoint until it responds OK or the timeout elapses.
  * The first `docker run` pulls the image, so the default window is generous.
@@ -165,19 +202,20 @@ export const createDockerRunner = () => ({
 export const pollHealth = async (params, fetchFn) => {
     const { url, timeoutMs = 120_000, intervalMs = 2_000 } = params;
     const deadline = Date.now() + timeoutMs;
-    const isHealthy = async () => {
-        try {
-            const response = await fetchFn(url);
-            return response.ok;
-        }
-        catch {
-            return false;
-        }
-    };
+    // Each attempt is bounded by the per-request cap AND the remaining budget
+    // (a bare remaining-budget bound would let one black-holed request consume
+    // the whole window with no retries), and the pause never sleeps past the
+    // deadline — so the loop can't overshoot timeoutMs and the caller's
+    // "did not respond within N minutes" message stays accurate.
     while (Date.now() < deadline) {
-        if (await isHealthy())
+        const attemptTimeoutMs = Math.min(PROBE_TIMEOUT_MS, deadline - Date.now());
+        if (await probeHealth({ url, timeoutMs: attemptTimeoutMs }, fetchFn)) {
             return true;
-        await new Promise((resolvePause) => setTimeout(resolvePause, intervalMs));
+        }
+        const pauseMs = Math.min(intervalMs, deadline - Date.now());
+        if (pauseMs > 0) {
+            await new Promise((resolvePause) => setTimeout(resolvePause, pauseMs));
+        }
     }
     return false;
 };

package/dist/env.js

@@ -10,10 +10,10 @@
 // └─────────────────────────────────────────────────────────────────────────┘
 // sync:local-optional:begin
 const LOCAL_OPTIONAL_BLOCK = `# Optional ──────────────────────────────────────────────────
-# To change a setting: run "npx vault-cortex configure", or edit its
-# value here (uncommenting it first if needed) and apply with
-# "npx vault-cortex restart" (plain docker restart does not re-read
-# this file).
+# To change a setting: run "npx vault-cortex@latest configure", or edit
+# its value here (uncommenting it first if needed) and apply with
+# "npx vault-cortex@latest restart" (plain docker restart does not
+# re-read this file).
 
 # Public URL for OAuth issuer URL in discovery metadata (default: http://localhost:8000).
 # Override if you expose the server on a different URL (e.g. via a reverse proxy).
@@ -61,12 +61,21 @@ FILE_TOOLS_ENABLED=true
 # Memory folder name in your vault (default: About Me).
 MEMORY_DIR=About Me
 
-# Comma-separated folders protected from deletion (default: MEMORY_DIR, Daily Notes).
-# If your daily notes folder has a custom name (e.g. "Journal"), override to include it.
+# Daily notes folder and filename format (default: read from the
+# vault's .obsidian/daily-notes.json, falling back to "Daily Notes" and
+# YYYY-MM-DD). Folder is any vault-relative path (Journal, Planner/Daily);
+# format takes the same tokens as Obsidian's date format setting.
+# DAILY_NOTES_FOLDER=Journal
+# DAILY_NOTES_FORMAT=YYYY-MM-DD
+
+# Comma-separated folders protected from deletion (default: MEMORY_DIR plus
+# the daily notes folder — DAILY_NOTES_FOLDER when set, otherwise "Daily Notes").
+# A custom folder set only in daily-notes.json is not auto-protected.
 # PROTECTED_PATHS=About Me,Daily Notes
 
-# Comma-separated folders excluded from orphan detection
-# (default: Daily Notes, Templates, MEMORY_DIR).
+# Comma-separated folders excluded from orphan detection (default: the daily
+# notes folder — DAILY_NOTES_FOLDER when set, otherwise "Daily Notes" — plus
+# Templates and MEMORY_DIR).
 # ORPHAN_EXCLUDE_FOLDERS=Daily Notes,Templates,About Me
 
 # URL shown in OAuth discovery metadata
@@ -101,10 +110,10 @@ WINDOWS_MODE=false
 // └─────────────────────────────────────────────────────────────────────────┘
 // sync:remote-optional:begin
 const REMOTE_OPTIONAL_BLOCK = `# Optional ──────────────────────────────────────────────────
-# To change a setting: run "npx vault-cortex configure", or edit its
-# value here (uncommenting it first if needed) and apply with
-# "npx vault-cortex restart" (plain docker restart does not re-read
-# this file).
+# To change a setting: run "npx vault-cortex@latest configure", or edit
+# its value here (uncommenting it first if needed) and apply with
+# "npx vault-cortex@latest restart" (plain docker restart does not
+# re-read this file).
 
 # Your IANA timezone — affects daily note resolution and memory timestamps.
 # TZ=America/New_York
@@ -154,12 +163,22 @@ FILE_TOOLS_ENABLED=true
 # Memory folder name in your vault (default: About Me).
 MEMORY_DIR=About Me
 
-# Comma-separated folders protected from deletion (default: MEMORY_DIR, Daily Notes).
-# If your daily notes folder has a custom name (e.g. "Journal"), override to include it.
+# Daily notes folder and filename format (default: read from the
+# vault's .obsidian/daily-notes.json, synced to the server via SYNC_CONFIGS
+# below; falls back to "Daily Notes" and YYYY-MM-DD). Folder is any
+# vault-relative path (Journal, Planner/Daily); format takes the same tokens
+# as Obsidian's date format setting.
+# DAILY_NOTES_FOLDER=Journal
+# DAILY_NOTES_FORMAT=YYYY-MM-DD
+
+# Comma-separated folders protected from deletion (default: MEMORY_DIR plus
+# the daily notes folder — DAILY_NOTES_FOLDER when set, otherwise "Daily Notes").
+# A custom folder set only in daily-notes.json is not auto-protected.
 # PROTECTED_PATHS=About Me,Daily Notes
 
-# Comma-separated folders excluded from orphan detection
-# (default: Daily Notes, Templates, MEMORY_DIR).
+# Comma-separated folders excluded from orphan detection (default: the daily
+# notes folder — DAILY_NOTES_FOLDER when set, otherwise "Daily Notes" — plus
+# Templates and MEMORY_DIR).
 # ORPHAN_EXCLUDE_FOLDERS=Daily Notes,Templates,About Me
 
 # URL shown in OAuth discovery metadata
@@ -192,10 +211,21 @@ CONFLICT_STRATEGY=merge
 
 # Sync direction: bidirectional | pull-only | push-only (default: bidirectional).
 SYNC_MODE=bidirectional
+
+# Obsidian settings categories to sync into the server's .obsidian/ folder
+# (default: the two the server reads — daily notes settings and community
+# plugin settings such as the Tasks plugin's format; "none" disables).
+# A category only syncs after your desktop pushes it: Obsidian Settings →
+# Sync → "Vault configuration sync" (per device). Some community plugins
+# keep API keys in their settings — server tools never read .obsidian/,
+# but synced settings do live on the server volume. Values: app,
+# appearance, appearance-data, hotkey, core-plugin, core-plugin-data,
+# community-plugin, community-plugin-data — comma-separated.
+SYNC_CONFIGS=core-plugin-data,community-plugin-data
 `;
 // sync:remote-optional:end
 export const buildLocalEnv = (answers) => `# vault-cortex — local quickstart
-# Generated by \`npx vault-cortex init\`. Full option reference:
+# Generated by \`npx vault-cortex@latest init\`. Full option reference:
 # https://github.com/aliasunder/vault-cortex/blob/main/deploy/local/.env.example
 
 # Required ──────────────────────────────────────────────────
@@ -216,10 +246,10 @@ VAULT_PASSWORD=${answers.vaultPassword}`;
     const obsidianTokenComment = answers.obsidianAuthToken === ""
         ? `# Obsidian Sync auth token — FILL THIS IN before starting the server.
 # Generate once with:
-#   npx vault-cortex get-sync-token`
+#   npx vault-cortex@latest get-sync-token`
         : `# Obsidian Sync auth token.`;
     return `# vault-cortex — remote quickstart (Obsidian Sync)
-# Generated by \`npx vault-cortex init\`. Full option reference:
+# Generated by \`npx vault-cortex@latest init\`. Full option reference:
 # https://github.com/aliasunder/vault-cortex/blob/main/deploy/remote/.env.example
 
 # Required ──────────────────────────────────────────────────

package/dist/get-sync-token.js

@@ -1,6 +1,7 @@
 import { existsSync, mkdtempSync, readFileSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join, resolve } from "node:path";
+import { buildDaemonNotRunningMessage, buildDockerNotInstalledMessage, } from "./messages.js";
 import { patchEnvObsidianToken } from "./scaffold.js";
 import { expandTilde } from "./vault.js";
 /** Message from an unknown throw — Error instances keep their message. */
@@ -90,14 +91,14 @@ export const captureObsidianToken = (deps, tokenDestinationMessage) => {
         const loginSucceeded = runLoginContainer(configMountPath, deps);
         if (!loginSucceeded) {
             prompts.warn("The Obsidian login did not complete — you can run it later with:\n" +
-                "  npx vault-cortex get-sync-token");
+                "  npx vault-cortex@latest get-sync-token");
             return undefined;
         }
         const token = readCapturedTokenFile(configMountPath);
         if (!token) {
             prompts.warn("The Obsidian login finished, but no token was captured — the " +
                 "token file was missing, empty, or unreadable. You can retry with:\n" +
-                "  npx vault-cortex get-sync-token");
+                "  npx vault-cortex@latest get-sync-token");
             return undefined;
         }
         return token;
@@ -113,9 +114,11 @@ export const captureObsidianToken = (deps, tokenDestinationMessage) => {
  */
 export const runGetSyncToken = async (flags, deps) => {
     const { prompts, docker } = deps;
-    if (!docker.isDaemonRunning()) {
-        prompts.error("Container runtime not running — start Docker Desktop, Colima,\n" +
-            "OrbStack, or another Docker-compatible runtime and try again.");
+    const daemonStatus = docker.daemonStatus();
+    if (daemonStatus !== "running") {
+        prompts.error(daemonStatus === "not-installed"
+            ? buildDockerNotInstalledMessage({ nextStep: "\nThen try again." })
+            : buildDaemonNotRunningMessage(" and try again."));
         return 1;
     }
     prompts.intro("vault-cortex get-sync-token");

package/dist/init.js

@@ -2,10 +2,11 @@ import { existsSync } from "node:fs";
 import { join, resolve } from "node:path";
 import { buildLocalEnv, buildRemoteEnv } from "./env.js";
 import { captureObsidianToken } from "./get-sync-token.js";
-import { buildLocalConnectMessage, buildRemoteConnectMessage, } from "./messages.js";
+import { buildDaemonNotRunningMessage, buildDockerNotInstalledMessage, buildLocalConnectMessage, buildRemoteConnectMessage, startCommand, } from "./messages.js";
 import { pollHealth } from "./docker.js";
+import { reportPublicUrlProbe } from "./lifecycle.js";
 import { applyOptionalSettings, askOptionalSettings, derivePublicUrlOverride, } from "./optional-settings.js";
-import { buildFilesToWrite, readEnvPort, writeFiles, } from "./scaffold.js";
+import { buildFilesToWrite, readEnvPort, readEnvPublicUrl, writeFiles, } from "./scaffold.js";
 import { generateToken } from "./token.js";
 import { expandTilde, validateVaultPath } from "./vault.js";
 const DEFAULT_TARGET_DIR = "./vault-cortex";
@@ -118,6 +119,26 @@ const askVaultName = async (prompts) => {
 const keepExisting = async () => false;
 /** Interactive conflict policy: ask per differing file, defaulting to keep. */
 const confirmOverwrite = (prompts) => (name) => prompts.confirm(`${name} already exists and differs — overwrite?`, false);
+/**
+ * Re-init guard, fired the moment the target dir is known (prompt answer or
+ * --dir flag): an existing .env there means a live deployment, so the flow
+ * checks intent before any further questions are spent — re-running init over
+ * a deployment is usually an accident, and settings changes belong to
+ * `configure`. Declining (the default) backs out with pointers; accepting
+ * continues, still protected by the per-file overwrite confirms at write time.
+ */
+const confirmReinitOverExistingEnv = async (targetDir, prompts) => {
+    if (!existsSync(join(targetDir, ".env")))
+        return true;
+    prompts.log(`Found an existing deployment in ${targetDir}.`);
+    const reinitAnyway = await prompts.confirm("Re-run setup for this directory anyway?", false);
+    if (reinitAnyway)
+        return true;
+    // No outro here: declining still exits 0, and the runInit wrapper owns the
+    // closing outro (mirroring configure's declined-restart path).
+    prompts.log(`Nothing changed. To adjust settings instead: npx vault-cortex@latest configure --dir "${targetDir}"`);
+    return false;
+};
 const reportWrites = (params, prompts) => {
     const { targetDir, results } = params;
     for (const result of results) {
@@ -139,10 +160,14 @@ const reportWrites = (params, prompts) => {
 const offerDockerRun = async (params, deps) => {
     const { targetDir, port, mode, vaultPath } = params;
     const { prompts, docker, fetchFn } = deps;
-    if (!docker.isDaemonRunning()) {
-        prompts.warn("Container runtime not running — start Docker Desktop, Colima,\n" +
-            "OrbStack, or another Docker-compatible runtime, then run:\n" +
-            `  npx vault-cortex upgrade --dir "${targetDir}"`);
+    const daemonStatus = docker.daemonStatus();
+    if (daemonStatus !== "running") {
+        const startHint = startCommand(targetDir);
+        prompts.warn(daemonStatus === "not-installed"
+            ? buildDockerNotInstalledMessage({
+                nextStep: `\nThen start the server with:\n  ${startHint}`,
+            })
+            : buildDaemonNotRunningMessage(`, then run:\n  ${startHint}`));
         return false;
     }
     const startNow = await prompts.confirm("Start the server now?", true);
@@ -204,21 +229,25 @@ const runLocalInit = async (flags, deps) => {
                 defaultValue: DEFAULT_TARGET_DIR,
                 placeholder: DEFAULT_TARGET_DIR,
             }))));
+    // --yes skips the guard: it's non-interactive by contract, and its own
+    // conflict policy (refuse to overwrite, exit 1) already protects the dir.
+    if (!flags.yes) {
+        const continueReinit = await confirmReinitOverExistingEnv(targetDir, prompts);
+        if (!continueReinit)
+            return 0;
+    }
     const token = generateToken();
     // Guided optional settings: the chooser reads current values from the
     // generated defaults; enter with nothing picked keeps them all. --yes
-    // skips the chooser (non-interactive by contract), and so does an existing
-    // .env — the conflict prompt defaults to keeping it, which would discard
-    // the answers; settings on an existing deployment are configure's job.
+    // skips the chooser (non-interactive by contract). An existing .env does
+    // NOT skip it: every interactive path here passed the re-init guard, so the
+    // user asked for a full re-run — the answers land in the regenerated file
+    // when they overwrite at the conflict prompt (keeping it discards them,
+    // which the write report states). In-place edits stay configure's job.
     const defaultEnvContent = buildLocalEnv({ mcpAuthToken: token, vaultPath });
-    const envAlreadyExists = existsSync(join(targetDir, ".env"));
-    const offerSettingsChooser = !flags.yes && !envAlreadyExists;
-    if (!flags.yes && envAlreadyExists) {
-        prompts.log('Found an existing .env — settings prompts skipped. Adjust settings with "npx vault-cortex configure".');
-    }
-    const optionalOverrides = offerSettingsChooser
-        ? await askOptionalSettings({ mode: "local", envContent: defaultEnvContent }, prompts)
-        : {};
+    const optionalOverrides = flags.yes
+        ? {}
+        : await askOptionalSettings({ mode: "local", envContent: defaultEnvContent }, prompts);
     const envContent = applyOptionalSettings(defaultEnvContent, derivePublicUrlOverride(defaultEnvContent, optionalOverrides));
     // Conflict policy: identical existing files are skipped silently;
     // differing ones prompt per file (default keep). --yes never overwrites —
@@ -261,12 +290,17 @@ const runRemoteInit = async (flags, deps) => {
             defaultValue: DEFAULT_TARGET_DIR,
             placeholder: DEFAULT_TARGET_DIR,
         }))));
+    const continueReinit = await confirmReinitOverExistingEnv(targetDir, prompts);
+    if (!continueReinit)
+        return 0;
     const publicUrl = await askPublicUrl(prompts);
     const vaultName = await askVaultName(prompts);
     // Auto-capture the Obsidian Sync token via a Docker volume mount when
     // the daemon is reachable. Falls back to a paste prompt when capture
-    // fails or the user declines.
-    const capturedToken = docker.isDaemonRunning()
+    // fails or the user declines. Both non-running states stay silent here —
+    // the paste fallback is fully functional without Docker, and the start
+    // offer surfaces the differentiated runtime guidance later in the flow.
+    const capturedToken = docker.daemonStatus() === "running"
         ? await offerSyncTokenCapture(prompts, docker)
         : undefined;
     // Masked prompt: the sync token is a credential and must not echo into
@@ -280,8 +314,10 @@ const runRemoteInit = async (flags, deps) => {
         : undefined;
     const token = generateToken();
     // Guided optional settings, mirroring the local flow — remote also offers
-    // SYNC_MODE. Remote init is always interactive (no --yes), so only an
-    // existing .env skips the chooser here.
+    // SYNC_MODE. Remote init is always interactive (no --yes), and any existing
+    // .env passed the re-init guard — a consented re-run gets the full setup,
+    // chooser included (see the local flow's comment for the overwrite/keep
+    // semantics).
     const defaultEnvContent = buildRemoteEnv({
         mcpAuthToken: token,
         publicUrl,
@@ -289,13 +325,7 @@ const runRemoteInit = async (flags, deps) => {
         vaultName,
         vaultPassword,
     });
-    const envAlreadyExists = existsSync(join(targetDir, ".env"));
-    if (envAlreadyExists) {
-        prompts.log('Found an existing .env — settings prompts skipped. Adjust settings with "npx vault-cortex configure".');
-    }
-    const optionalOverrides = envAlreadyExists
-        ? {}
-        : await askOptionalSettings({ mode: "remote", envContent: defaultEnvContent }, prompts);
+    const optionalOverrides = await askOptionalSettings({ mode: "remote", envContent: defaultEnvContent }, prompts);
     const envContent = applyOptionalSettings(defaultEnvContent, derivePublicUrlOverride(defaultEnvContent, optionalOverrides));
     const files = buildFilesToWrite(envContent);
     const results = await writeFiles({ targetDir, files }, confirmOverwrite(prompts));
@@ -309,15 +339,28 @@ const runRemoteInit = async (flags, deps) => {
     if (tokenWritten)
         prompts.log("Generated MCP auth token (saved to .env).");
     const port = readEnvPort(join(targetDir, ".env"));
+    // Like PORT above, PUBLIC_URL comes from the .env actually on disk — a kept
+    // existing file may hold a different URL than this run's prompt, and the
+    // server only reads the file. The prompted value is the fallback for a kept
+    // legacy .env that predates PUBLIC_URL.
+    const effectivePublicUrl = readEnvPublicUrl(join(targetDir, ".env")) ?? publicUrl;
     // Without the sync token the container can't start (init-check-auth fails
     // and s6 stops it), so only offer docker run when it was provided.
     const started = obsidianAuthToken === ""
         ? false
         : await offerDockerRun({ targetDir, port, mode: "remote" }, deps);
+    // The container check above hit localhost on this machine; the public URL
+    // is the ingress path clients actually use — probe it too, informationally.
+    if (started) {
+        await reportPublicUrlProbe(effectivePublicUrl, {
+            prompts,
+            fetchFn: deps.fetchFn,
+        });
+    }
     prompts.print(buildRemoteConnectMessage({
         targetDir,
         token,
-        publicUrl,
+        publicUrl: effectivePublicUrl,
         started,
         obsidianTokenMissing: obsidianAuthToken === "",
         tokenWritten,

package/dist/lifecycle.js

@@ -1,6 +1,7 @@
 import { join, resolve } from "node:path";
-import { CONTAINER_NAME, pollHealth } from "./docker.js";
-import { detectMode, hasEnvPublicUrl, readEnvPort, readEnvVaultPath, } from "./scaffold.js";
+import { CONTAINER_NAME, pollHealth, probeHealth, } from "./docker.js";
+import { buildDaemonNotRunningMessage, buildDockerNotInstalledMessage, } from "./messages.js";
+import { detectMode, hasEnvPublicUrl, readEnvPort, readEnvPublicUrl, readEnvVaultPath, } from "./scaffold.js";
 import { expandTilde } from "./vault.js";
 const DEFAULT_TARGET_DIR = "./vault-cortex";
 /**
@@ -13,7 +14,7 @@ export const requireInitializedDir = (dirFlag, prompts) => {
     const envFilePath = join(targetDir, ".env");
     const mode = detectMode(envFilePath);
     if (!mode) {
-        prompts.error(`No .env found in ${targetDir} — run \`npx vault-cortex init\` first.`);
+        prompts.error(`No .env found in ${targetDir} — run \`npx vault-cortex@latest init\` first.`);
         return undefined;
     }
     return { targetDir, envFilePath, mode };
@@ -40,19 +41,58 @@ export const resolveDeployment = (dirFlag, prompts) => {
             `Add this line to your .env:\n  PUBLIC_URL=http://localhost:${port}`);
         return undefined;
     }
-    return { mode, targetDir, envFilePath, port, vaultPath };
+    const publicUrl = readEnvPublicUrl(envFilePath);
+    return { mode, targetDir, envFilePath, port, vaultPath, publicUrl };
 };
 /**
  * Verifies the container runtime is reachable, reporting the shared error
  * message when it isn't. Callers early-return on false.
  */
 export const ensureDaemonRunning = (docker, prompts) => {
-    if (docker.isDaemonRunning())
+    const daemonStatus = docker.daemonStatus();
+    if (daemonStatus === "running")
         return true;
-    prompts.error("Container runtime not running — start Docker Desktop, Colima,\n" +
-        "OrbStack, or another Docker-compatible runtime.");
+    prompts.error(daemonStatus === "not-installed"
+        ? buildDockerNotInstalledMessage({ nextStep: "" })
+        : buildDaemonNotRunningMessage("."));
     return false;
 };
+/**
+ * Whether the post-start public-URL probe should run — and, when it should,
+ * proof that publicUrl is set. Local's PUBLIC_URL is the derived localhost
+ * URL, so probing it would only duplicate the health check the start cycle
+ * just ran.
+ */
+const shouldRunPostStartProbe = (deployment) => {
+    return deployment.mode === "remote" && deployment.publicUrl !== undefined;
+};
+/**
+ * One-shot informational probe of the public /healthz after a confirmed
+ * container start. Never a gate: a failure warns and the command still
+ * succeeds — before HTTPS/ingress access is set up an unreachable public URL
+ * is the expected state, and this machine's result doesn't prove the same
+ * for other devices (a VPS may not reach its own public address). Returning
+ * void keeps the informational contract structural.
+ */
+export const reportPublicUrlProbe = async (publicUrl, deps) => {
+    const { prompts, fetchFn } = deps;
+    // A hand-edited .env value may carry a trailing slash; strip it so the
+    // probe URL is `${base}/healthz`, never `${base}//healthz`.
+    const healthUrl = `${publicUrl.replace(/\/+$/, "")}/healthz`;
+    const spinner = prompts.spinner();
+    spinner.start(`Checking the public URL (${healthUrl})`);
+    const publicUrlResponded = await probeHealth({ url: healthUrl }, fetchFn);
+    if (publicUrlResponded) {
+        spinner.stop(`Public URL responds — ${healthUrl} answered from this machine.`);
+        return;
+    }
+    spinner.stop(`No answer from ${healthUrl} yet.`);
+    prompts.warn("The server is up, but its public URL didn't answer from this machine.\n" +
+        "That's expected until HTTPS (or direct port) access is set up — and\n" +
+        "some networks keep a server from reaching its own public address even\n" +
+        "when other devices can. Once access is set up, check from any device:\n" +
+        `  curl ${healthUrl}`);
+};
 /**
  * Stop-and-remove → docker run → health poll, with the shared messaging.
  * Returns a process exit code. Callers own the daemon check and any
@@ -92,6 +132,11 @@ export const recreateContainer = async (params, deps) => {
         return 1;
     }
     spinner.stop("Server is up — health check passed.");
+    // Informational only — the container is confirmed healthy above, so the
+    // public-URL result never changes the exit code.
+    if (shouldRunPostStartProbe(deployment)) {
+        await reportPublicUrlProbe(deployment.publicUrl, { prompts, fetchFn });
+    }
     return 0;
 };
 /**
@@ -119,7 +164,7 @@ export const runDown = async (flags, deps) => {
         return 1;
     }
     prompts.log("Container stopped and removed. Your vault data, search index, and settings are untouched.");
-    prompts.outro(`Start again with: npx vault-cortex restart --dir "${initialized.targetDir}"`);
+    prompts.outro(`Start again with: npx vault-cortex@latest start --dir "${initialized.targetDir}"`);
     return 0;
 };
 /**
@@ -136,7 +181,7 @@ export const runLogs = async (flags, deps) => {
     if (!ensureDaemonRunning(docker, prompts))
         return 1;
     if (!docker.containerExists()) {
-        prompts.error("No vault-cortex container — start it with `npx vault-cortex restart`.");
+        prompts.error(`No vault-cortex container — start it with: npx vault-cortex@latest start --dir "${initialized.targetDir}"`);
         return 1;
     }
     return await docker.streamLogs({
@@ -145,13 +190,13 @@ export const runLogs = async (flags, deps) => {
     });
 };
 /**
- * Re-creates the container from the .env on disk and verifies health.
- * Unlike `docker restart`, this applies .env edits (the env-file is only
- * read at container creation); unlike upgrade, it never pulls an image.
+ * Shared start/restart cycle: re-create the container from the .env on disk
+ * and verify health. One implementation, two command names — the labels are
+ * the only divergence, phrased for the intent each name serves.
  */
-export const runRestart = async (flags, deps) => {
+const runRecreateFromEnv = async (flags, deps, labels) => {
     const { prompts, docker, fetchFn } = deps;
-    prompts.intro("vault-cortex restart");
+    prompts.intro(labels.introTitle);
     const deployment = resolveDeployment(flags.dir, prompts);
     if (!deployment)
         return 1;
@@ -160,7 +205,33 @@ export const runRestart = async (flags, deps) => {
     const exitCode = await recreateContainer({ deployment, healthTimeoutMs: deps.healthTimeoutMs }, { prompts, docker, fetchFn });
     if (exitCode !== 0)
         return exitCode;
-    prompts.log("Applied the current .env settings.");
-    prompts.outro("Restart complete.");
+    prompts.log(labels.successLog);
+    prompts.outro(labels.outroMessage);
     return 0;
 };
+/**
+ * Starts the server from the saved .env — the command name users reach for
+ * when nothing is running yet (after `down`, or an init that skipped the
+ * start offer). Same cycle as restart: if a container is already running it
+ * is safely replaced, and `docker run` pulls the image when it's missing.
+ */
+export const runStart = async (flags, deps) => {
+    return runRecreateFromEnv(flags, deps, {
+        introTitle: "vault-cortex start",
+        successLog: "Started with the settings from .env.",
+        outroMessage: "Start complete.",
+    });
+};
+/**
+ * Re-creates the container from the .env on disk and verifies health.
+ * Unlike `docker restart`, this applies .env edits (the env-file is only
+ * read at container creation); unlike upgrade, it never replaces an image
+ * you already have (`docker run` still pulls when none exists locally).
+ */
+export const runRestart = async (flags, deps) => {
+    return runRecreateFromEnv(flags, deps, {
+        introTitle: "vault-cortex restart",
+        successLog: "Applied the current .env settings.",
+        outroMessage: "Restart complete.",
+    });
+};

package/dist/main.js

@@ -2,7 +2,7 @@ import { runConfigure } from "./configure.js";
 import { createDockerRunner } from "./docker.js";
 import { runGetSyncToken } from "./get-sync-token.js";
 import { runInit } from "./init.js";
-import { runDown, runLogs, runRestart } from "./lifecycle.js";
+import { runDown, runLogs, runRestart, runStart } from "./lifecycle.js";
 import { buildProgram } from "./program.js";
 import { createPrompts } from "./prompts.js";
 import { runUpgrade } from "./upgrade.js";
@@ -24,6 +24,11 @@ export const run = async (version) => {
             docker: createDockerRunner(),
             fetchFn: fetch,
         }),
+        runStart: (flags) => runStart(flags, {
+            prompts: createPrompts(),
+            docker: createDockerRunner(),
+            fetchFn: fetch,
+        }),
         runRestart: (flags) => runRestart(flags, {
             prompts: createPrompts(),
             docker: createDockerRunner(),

package/dist/messages.js

@@ -10,17 +10,53 @@ const RULE_WIDTH = 56;
 const topRule = (label) => paint("dim", `╭── ${label} ${"─".repeat(Math.max(0, RULE_WIDTH - label.length - 6))}╮`);
 const bottomRule = () => paint("dim", `╰${"─".repeat(RULE_WIDTH - 2)}╯`);
 const sectionRule = (label) => paint("dim", `── ${label} ${"─".repeat(Math.max(0, RULE_WIDTH - label.length - 4))}`);
+/**
+ * Daemon-stopped guidance shared by every command that needs the container
+ * runtime. `nextStep` finishes the message per command — appended verbatim
+ * (".", " and try again.", or a ", then run:" continuation).
+ */
+export const buildDaemonNotRunningMessage = (nextStep) => "Container runtime not running — start Docker Desktop, Colima,\n" +
+    `OrbStack, or another Docker-compatible runtime${nextStep}`;
+/**
+ * Per-platform install pointer — a docs link only, no install method
+ * suggestions: the CLI doesn't install anything, so the official docs (which
+ * cover every method) are the hand-off. Peers are named in the message above
+ * this line.
+ */
+const dockerInstallLine = (platform) => {
+    if (platform === "darwin" || platform === "win32") {
+        return "Install Docker Desktop: https://docs.docker.com/get-docker/";
+    }
+    return "Install Docker Engine: https://docs.docker.com/engine/install/";
+};
+/**
+ * "No runtime at all" guidance — distinct from the daemon-stopped message so
+ * the user isn't told to start something that isn't installed. platform is a
+ * defaulted param (mirroring buildObsidianLoginArgs) so each branch stays
+ * testable; `nextStep` is appended verbatim, as in
+ * buildDaemonNotRunningMessage.
+ */
+export const buildDockerNotInstalledMessage = (params) => {
+    const { nextStep, platform = process.platform } = params;
+    return ("No container runtime found — the server runs in Docker, so you need\n" +
+        "Docker or a Docker-compatible runtime (OrbStack, Colima, Podman).\n" +
+        `${dockerInstallLine(platform)}${nextStep}`);
+};
 // targetDir is quoted: these lines are meant to be copy-pasted into a
 // shell, and an unquoted path breaks on spaces or special characters.
-const upgradeCommand = (targetDir) => `npx vault-cortex upgrade --dir "${targetDir}"`;
-const startServerLine = (targetDir) => `Start the server:\n  ${upgradeCommand(targetDir)}`;
+const upgradeCommand = (targetDir) => `npx vault-cortex@latest upgrade --dir "${targetDir}"`;
+// Start guidance prints `start`, not `upgrade` — telling a user who has never
+// started anything to run "upgrade" reads as updating something they don't
+// have. `start` runs the same re-create cycle and pulls the image on demand.
+export const startCommand = (targetDir) => `npx vault-cortex@latest start --dir "${targetDir}"`;
+const startServerLine = (targetDir) => `Start the server:\n  ${startCommand(targetDir)}`;
 /** Remote start line: running, blocked on the missing sync token, or ready to start. */
 const remoteStartLine = (params) => {
     const { targetDir, started, obsidianTokenMissing } = params;
     if (started)
         return "The server is running.";
     if (obsidianTokenMissing) {
-        return `Fill in OBSIDIAN_AUTH_TOKEN in ${targetDir}/.env, then start the server:\n  ${upgradeCommand(targetDir)}`;
+        return `Fill in OBSIDIAN_AUTH_TOKEN in ${targetDir}/.env, then start the server:\n  ${startCommand(targetDir)}`;
     }
     return startServerLine(targetDir);
 };
@@ -62,6 +98,19 @@ const curlGuidance = (mcpUrl) => `Clients without OAuth, scripts, and curl send
   curl -H "Authorization: Bearer <token>" ${mcpUrl}`;
 const smokeTest = (healthUrl) => `Smoke test:
   curl ${healthUrl}`;
+/**
+ * Remote health-check block. Started: the CLI verified localhost on the VPS,
+ * but the public URL is a different check (ingress — DNS, TLS, proxy), so the
+ * command stays, reworded as the works-from-any-device check. Not started:
+ * the plain smoke test to run after starting.
+ */
+const remoteHealthCheckBlock = (healthUrl, started) => {
+    if (started) {
+        return `Health check — works from any device that can reach the URL:
+  curl ${healthUrl}`;
+    }
+    return smokeTest(healthUrl);
+};
 const updateGuidance = (targetDir) => `Update to the latest release:
   ${upgradeCommand(targetDir)}`;
 /**
@@ -76,6 +125,15 @@ export const buildLocalConnectMessage = (params) => {
         ? "The server is running."
         : startServerLine(targetDir);
     const tokenLine = tokenBlock({ targetDir, token, tokenWritten });
+    // Once the server is confirmed up, the smoke test is dropped — the CLI just
+    // verified this exact URL, so re-printing it reads as leftover homework.
+    // Assembled as a filtered list so the omission leaves no stray blank line.
+    const nonOauthBlocks = [
+        curlGuidance(`${baseUrl}/mcp`),
+        started ? undefined : smokeTest(`${baseUrl}/healthz`),
+    ]
+        .filter(Boolean)
+        .join("\n\n");
     // Flush-left on purpose: this is printed as plain text (see paint), so
     // leading whitespace would render as literal indentation. Local is always
     // localhost http, so it shares the http guidance; its only divergences are
@@ -104,18 +162,16 @@ it with mcp-remote:
 
 ${sectionRule("Non-OAuth")}
 
-${curlGuidance(`${baseUrl}/mcp`)}
-
-${smokeTest(`${baseUrl}/healthz`)}
+${nonOauthBlocks}
 
 ${sectionRule("Settings")}
 
-Adjust optional settings (memory layer and folder, file tools,
-semantic search, port, timezone):
-  npx vault-cortex configure --dir "${targetDir}"
+Adjust optional settings (memory layer and folder, daily notes
+folder and format, file tools, semantic search, port, timezone):
+  npx vault-cortex@latest configure --dir "${targetDir}"
 
 Or edit ${targetDir}/.env directly — change a value (uncommenting it
-first if needed), then apply with "npx vault-cortex restart" (plain
+first if needed), then apply with "npx vault-cortex@latest restart" (plain
 docker restart does not re-read .env).
 
 ${updateGuidance(targetDir)}
@@ -171,16 +227,17 @@ ${sectionRule("Non-OAuth")}
 
 ${curlGuidance(`${publicUrl}/mcp`)}
 
-${smokeTest(`${publicUrl}/healthz`)}
+${remoteHealthCheckBlock(`${publicUrl}/healthz`, started)}
 
 ${sectionRule("Settings")}
 
-Adjust optional settings (memory layer and folder, file tools,
-semantic search, port, timezone, sync direction):
-  npx vault-cortex configure --dir "${targetDir}"
+Adjust optional settings (memory layer and folder, daily notes
+folder and format, file tools, semantic search, port, timezone,
+sync direction):
+  npx vault-cortex@latest configure --dir "${targetDir}"
 
 Or edit ${targetDir}/.env directly — change a value (uncommenting it
-first if needed), then apply with "npx vault-cortex restart" (plain
+first if needed), then apply with "npx vault-cortex@latest restart" (plain
 docker restart does not re-read .env).
 
 ${updateGuidance(targetDir)}

package/dist/optional-settings.js

@@ -17,6 +17,20 @@ const OPTIONAL_SETTINGS = [
         defaultValue: "About Me",
         requiresToggle: "MEMORY_ENABLED",
     },
+    {
+        kind: "optionalText",
+        name: "DAILY_NOTES_FOLDER",
+        label: "Daily notes folder",
+        question: "Vault folder for daily notes:",
+        placeholder: "blank = use your vault's daily notes settings",
+    },
+    {
+        kind: "optionalText",
+        name: "DAILY_NOTES_FORMAT",
+        label: "Daily notes format",
+        question: "Filename date format for daily notes (e.g. YYYY-MM-DD):",
+        placeholder: "blank = use your vault's daily notes settings",
+    },
     {
         kind: "toggle",
         name: "FILE_TOOLS_ENABLED",
@@ -176,7 +190,34 @@ const askFolder = async (params, prompts) => {
     prompts.error("The folder name can't be empty.");
     return askFolder(params, prompts);
 };
-/** Routes a picked setting to its kind's prompt and returns the .env value. */
+/**
+ * Text prompt for a setting whose absence is meaningful — the server falls
+ * back to the vault's own config when the var is unset. Blank-when-unset
+ * writes nothing; blank-when-set keeps the current value. Returns undefined
+ * on skip or no-op so the caller never rewrites for nothing. No removal
+ * path — clearing is a manual .env edit.
+ */
+const askOptionalText = async (params, prompts) => {
+    const { question, placeholder, currentValue } = params;
+    const answer = (await prompts.text(question, {
+        defaultValue: currentValue,
+        placeholder: currentValue === undefined
+            ? placeholder
+            : "blank = keep the current value",
+    })).trim();
+    if (answer !== "" && answer !== currentValue)
+        return answer;
+    if (currentValue === undefined) {
+        prompts.log("Left unset — the server reads this setting from your vault's own config.");
+        return undefined;
+    }
+    prompts.log(`Kept the current value (${currentValue}).`);
+    return undefined;
+};
+/**
+ * Routes a picked setting to its kind's prompt and returns the .env value —
+ * or undefined when an optionalText prompt was left blank (nothing to write).
+ */
 const askSettingValue = async (params, prompts) => {
     const { setting, currentValue } = params;
     switch (setting.kind) {
@@ -194,6 +235,12 @@ const askSettingValue = async (params, prompts) => {
                 currentValue,
                 defaultValue: setting.defaultValue,
             }, prompts);
+        case "optionalText":
+            return askOptionalText({
+                question: setting.question,
+                placeholder: setting.placeholder,
+                currentValue,
+            }, prompts);
         case "choice":
             return prompts.select(setting.question, setting.choices, currentValue ?? setting.defaultValue);
     }
@@ -222,12 +269,15 @@ export const askOptionalSettings = async (params, prompts) => {
     });
     const pickedNames = await prompts.multiselect("Any optional settings to change? (press enter to skip)", chooserOptions);
     // Sequential prompting: answers are gathered one at a time in the curated
-    // order, so the record builds up inside an honest loop.
+    // order, so the record builds up inside an honest loop. An undefined answer
+    // (an optionalText prompt left blank) writes nothing.
     const overrides = {};
     for (const setting of offeredSettings) {
         if (!pickedNames.includes(setting.name))
             continue;
-        overrides[setting.name] = await askSettingValue({ setting, currentValue: readOptionalValue(envContent, setting.name) }, prompts);
+        const value = await askSettingValue({ setting, currentValue: readOptionalValue(envContent, setting.name) }, prompts);
+        if (value !== undefined)
+            overrides[setting.name] = value;
     }
     return overrides;
 };

package/dist/program.js

@@ -29,6 +29,13 @@ export const buildProgram = (options) => {
         .action(async (flags) => {
         process.exitCode = await options.runUpgrade(flags);
     });
+    program
+        .command("start")
+        .description("Start the server with the saved settings and verify health (same cycle as restart)")
+        .option("--dir <path>", "directory containing .env (default: ./vault-cortex)")
+        .action(async (flags) => {
+        process.exitCode = await options.runStart(flags);
+    });
     program
         .command("restart")
         .description("Re-create the container from .env and verify health (applies .env edits; no image pull)")

package/dist/scaffold.js

@@ -8,6 +8,8 @@ const ENV_PORT_LINE = /^PORT=(\d+)\s*$/m;
 const ENV_VAULT_PATH_LINE = /^VAULT_PATH=(.+)\s*$/m;
 /** Matches an active (uncommented) PUBLIC_URL line. */
 const ENV_PUBLIC_URL_LINE = /^PUBLIC_URL=/m;
+/** Matches an active (uncommented) PUBLIC_URL line, capturing a non-empty value. */
+const ENV_PUBLIC_URL_VALUE_LINE = /^PUBLIC_URL=(.+)\s*$/m;
 /** Matches an active (uncommented) OBSIDIAN_AUTH_TOKEN line. */
 const OBSIDIAN_AUTH_TOKEN_LINE = /^OBSIDIAN_AUTH_TOKEN=/m;
 export const buildFilesToWrite = (envContent) => [
@@ -38,14 +40,36 @@ export const readEnvVaultPath = (envFilePath) => {
 };
 /**
  * Returns true when the .env file has an active (uncommented) PUBLIC_URL line.
- * Used by upgrade to detect .env files from the old compose-based CLI, where
- * PUBLIC_URL was provided by docker-compose defaults rather than the .env.
+ * It's the FALSE result that carries the signal: the old compose-based CLI's
+ * generated .env never held a PUBLIC_URL line (the compose file's environment
+ * defaults supplied it), so a local .env without one predates the docker-run
+ * migration — callers use the negation to ask the user to add the line
+ * instead of starting a server missing a required variable.
  */
 export const hasEnvPublicUrl = (envFilePath) => {
     if (!existsSync(envFilePath))
         return false;
     return ENV_PUBLIC_URL_LINE.test(readFileSync(envFilePath, "utf8"));
 };
+/**
+ * Reads the public URL value from a .env file. Returns undefined when the
+ * file is missing or has no uncommented, non-empty PUBLIC_URL line —
+ * deliberately stricter than hasEnvPublicUrl, whose job is old-compose
+ * detection and so matches an empty `PUBLIC_URL=` line too.
+ */
+export const readEnvPublicUrl = (envFilePath) => {
+    if (!existsSync(envFilePath))
+        return undefined;
+    const match = ENV_PUBLIC_URL_VALUE_LINE.exec(readFileSync(envFilePath, "utf8"));
+    // A whitespace-only line matches the regex and trims to "" — normalize to
+    // undefined so the non-empty contract holds ("" is never a legitimate URL).
+    const publicUrlValue = match?.[1].trim();
+    // Strip trailing slashes (mirroring askPublicUrl's prompt-side
+    // normalization): consumers append paths to this base, and a hand-edited
+    // `https://host/` would otherwise print broken `//mcp` connect URLs.
+    const normalizedPublicUrl = publicUrlValue?.replace(/\/+$/, "");
+    return normalizedPublicUrl || undefined;
+};
 /**
  * Detects the deployment mode from a .env file. Remote mode requires
  * OBSIDIAN_AUTH_TOKEN (absent from local). Returns undefined when the

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "vault-cortex",
-  "version": "0.9.0",
-  "description": "Set up a Vault Cortex MCP server for your Obsidian vault in one command: npx vault-cortex init",
+  "version": "0.10.1-beta.48",
+  "description": "Set up a Vault Cortex MCP server for your Obsidian vault in one command: npx vault-cortex@latest init",
   "license": "MIT",
   "type": "module",
   "bin": {
@@ -28,18 +28,23 @@
     "mcp-server",
     "model-context-protocol",
     "obsidian",
-    "obsidian-mcp",
+    "obsidian-mcp-server",
     "obsidian-vault",
+    "obsidian-sync",
+    "ai-agents",
     "ai-memory",
-    "memory",
+    "ai-memory-system",
     "knowledge-base",
     "note-taking",
-    "second-brain",
+    "pkm",
+    "personal-knowledge-management",
     "hybrid-search",
     "task-management",
     "semantic-search",
     "attachments",
     "pdf",
+    "self-hosted",
+    "docker",
     "claude",
     "cli"
   ],