@krimto-labs/krimto 0.2.32 → 0.2.35

package/README.md

@@ -9,28 +9,55 @@ place and reads the right slice of it — Alice's preferences override the team'
 conventions override the org's standards, and every fact carries a paper trail (author, source,
 timestamp, reviewer).
 
-> **Where we are:** **v0.2.18** is the current published release — a consolidated UX redesign over
-> the v0.2.16 storage / index / access layers (which are all unchanged). Everything from v0.2.16
-> (markdown-in-git storage, `user → team → org` hierarchy, hybrid retrieval, server-enforced access,
-> two-way git sync, MCP over stdio + HTTP, the Docker image, the web UI, the complete CLI) is still
-> here, plus a substantial UX redesign on top. What's new in v0.2.18:
+> **Where we are:** **v0.2.35** is the current release — the v0.2.17 wizard redesign is now
+> shipped end-to-end, plus eighteen patch releases of correctness fixes and agent-friendly
+> surface. The v0.2.16 architecture (markdown-in-git storage, `user → team → org` hierarchy,
+> hybrid retrieval, server-enforced access, two-way git sync, MCP over stdio + HTTP, the Docker
+> image, the web UI) is unchanged. What you get on top of v0.2.16:
 >
-> - **One-command interactive setup wizard** (`krimto init`) — five questions with preselected
->   defaults; absorbs `connect`, `init`, `setup-remote`, and `setup-embeddings` into one flow.
-> - **Team-mode wizard** (`krimto team init` / `krimto join` / `krimto team disband`) — admins
->   onboard their team in one command; teammates join with a single line from a DM template.
-> - **Per-note CLI** (`krimto notes` / `edit` / `mv` / `supersede` / `tag`) — browse, search,
->   and edit notes from the terminal without opening the browser.
-> - **Settings shortcuts** (`krimto editors` / `search` / `service` / `reset`) — change one
->   thing without re-running the whole wizard. `reset` cleanly disconnects + uninstalls; `--wipe-notes`
->   moves data to a recoverable trash sibling, never `rm -rf`.
-> - **Notes-app `/ui`** — plain-English scope labels (Just me / Team name / Org name), inline
->   Edit + Move + Delete on every note, and a consolidated **Settings** page for the engineering
->   panels.
+> **The setup story (v0.2.17 → v0.2.21).**
+> - **One-command interactive setup wizard** (`krimto init`) — five questions, preselected
+>   defaults. Reads `git config user.email` for identity; detects editors at both project
+>   level (`.cursor/`, `CLAUDE.md`) and machine level (`~/.cursor/`, `~/.claude.json`).
+> - **Reconfigure menu** — re-runs of `krimto init` show a "Krimto on this machine:"
+>   summary with a real **Service:** line driven by lock + launchctl reality (not just
+>   config snapshot). "Keep current" prompts let you Enter-through.
 >
-> See [ROADMAP.md](ROADMAP.md), [CHANGELOG.md](CHANGELOG.md), and
-> [docs/krimto-v0.2.17-maria-journey.html](docs/krimto-v0.2.17-maria-journey.html) for the design
-> rationale and what each release added.
+> **The teardown story (v0.2.32 → v0.2.33).**
+> - **`krimto stop` / `start` / `restart`** — first-class verbs for the off-ramp the original
+>   wizard forgot. Idempotent. `stop` keeps the plist on disk so `start` can reload it.
+> - **`krimto reset [--yes] [--wipe-notes]`** — aggressive sweep across all editors (Cursor
+>   JSON + Claude Code CLI scopes user/project/local) + launchd/systemd uninstall + lock
+>   cleanup. `--wipe-notes` collapses to one named-consequence prompt.
+>
+> **The runtime story (v0.2.26 → v0.2.30).**
+> - **`/ui` notes-app redesign** — warm-paper Fraunces serif aesthetic, scope cards with
+>   emoji icons (📔 Just me / 📓 Team / 🏢 Org), notes timeline with per-row Edit / Move /
+>   Delete / View file. `krimto ui` opens it.
+> - **Single reconciled runtime view** (`inspectRuntime`) — every read-side command (status,
+>   verify-connection, whoami, reconfigure menu) routes through the same lock + launchctl +
+>   editor-config probe. No more "status says one thing, verify says another."
+> - **Service-first install ordering + port-ready probe** — wizard installs the service
+>   first, waits for `:8080` to accept TCP, then writes editor configs. Cursor's file
+>   watcher never fires into an unbound port (the v0.2.27/28 ECONNREFUSED fix).
+>
+> **The agent story (v0.2.34 → v0.2.35).**
+> - **Phase B agent flags** — `editors --add cursor`, `service --always`, `search --keyword`,
+>   `reset --yes`, `remote --set <url>`, `folder --to <path>`. Every command that used to
+>   open an interactive prompt now has a flag form.
+> - **Non-TTY guards** — interactive commands without flags exit 2 with copy-pasteable
+>   usage instead of hanging on an unanswerable prompt.
+> - **`krimto whoami` + `set identity <email>`** + a **`krimto_whoami` MCP tool** so agents
+>   stop hallucinating identity.
+> - **Editor attribution via User-Agent sniffing** — facts saved over HTTP automatically
+>   carry `source: "cursor"` / `"claude-code"` / etc., so the dashboard's "saved from a
+>   Cursor chat" line works without prompting agents.
+> - **Cursor `alwaysApply: true` frontmatter** so `.cursor/rules/krimto.mdc` auto-attaches
+>   instead of requiring the user to type "krimto" first.
+>
+> See [ROADMAP.md](ROADMAP.md), [CHANGELOG.md](CHANGELOG.md), and the proposal-vs-reality
+> diff in [docs/krimto-v0.2.17-maria-journey.html §09](docs/krimto-v0.2.17-maria-journey.html)
+> for the design rationale + what each patch caught.
 
 ## Try it in 90 seconds (solo, no account)
 
@@ -76,6 +103,33 @@ what your agent has been calling.
 **Power-user / CI:** `npx @krimto-labs/krimto init --yes` skips all prompts and applies
 defaults non-interactively. `--all` and `--minimal` keep their v0.2.16 meaning.
 
+### Setting Krimto up programmatically (AI agents, CI)
+
+Krimto is designed to be driven by Claude Code, Cursor, Codex, and similar AI agents that
+don't have a stdin TTY. Every interactive command has a flag form:
+
+```bash
+# The one-command full install (defaults: detected editors, as-needed run mode):
+krimto init --yes
+
+# Or pick the pieces:
+krimto editors --add cursor --add claude-code --yes    # wire editors
+krimto service --always                                # install background service
+krimto search --keyword                                # keyword search (default)
+krimto search --openai --api-key sk-...                # semantic search
+krimto remote --set git@github.com:acme/krimto.git     # cross-machine sync
+krimto status                                          # machine-readable check
+krimto stop / start / restart                          # idempotent service control
+```
+
+Run any interactive command (`editors`, `service`, `search`, `remote`, `folder`, `reset`)
+without a flag from a non-TTY shell and you get `exit 2` with copy-pasteable flag usage,
+not a hung-prompt warning. `krimto --help` has a dedicated **For AI agents (no TTY)**
+block at the top.
+
+The HTTP MCP handler also **sniffs `User-Agent`** to auto-stamp facts with `source:
+"cursor"` / `"claude-code"` / etc. — no agent-prompt convention needed.
+
 ## Connect your agent
 
 Krimto is one MCP server — point any client at `http://localhost:8080/mcp`. Verified for **Claude Code**
@@ -136,66 +190,77 @@ The in-product **Connect** page (`/ui/connect`) shows this same rule with a copy
 
 Everything is reachable via `npx`. Run `npx @krimto-labs/krimto --help` for the full list. All
 commands print clean, sectioned output with ✅ / ⚠️ / 🟢 status indicators and copy-paste shell
-commands. Grouped by purpose:
+commands. The seven groups below match `--help`'s structure.
 
 **Get connected (start here)**
 
 | Command | What it does |
 |---|---|
-| `init` | Interactive setup wizard — five questions, preselected defaults. Connects detected editors, applies the standing rule, optionally installs a background service. `--yes` skips prompts; legacy `--all` / `--minimal` still work. |
-| `serve` | Start the HTTP server (port 8080) + browser `/ui` dashboard |
-| `connect` | Print copy-paste config for Claude Code & Cursor (manual path) |
-| `uninit` | Strip the standing rule from this project's rules files |
+| `init [--yes]` | Interactive setup wizard — five questions, preselected defaults. Connects detected editors, applies the standing rule, optionally installs a background service. `--yes` skips prompts; legacy `--all` / `--minimal` still work. |
+| `connect` | Print copy-paste config for Claude Code & Cursor (manual path) — substitutes your real `git config user.email` for the identity. |
+| `uninit [--also-stop | --keep-running]` | Strip the standing rule from this project's rules files. Offers to stop the service too (or skip the prompt with the flags). |
 
-**Daily use** (v0.2.17-2 Phase D)
+**Look at your notes**
 
 | Command | What it does |
 |---|---|
 | `notes [query]` | List notes grouped by plain-English scope (`Just me` / team name / org name). With a query: ranked search via `krimto_recall`. |
-| `edit <id>` | Open the fact's `.md` in `$EDITOR`; reindexes on save. Validates frontmatter; restores immutable fields. |
-| `mv <id> <scope>` | Move a note between scopes (id preserved). Refuses if `canWrite` fails on either side. `user/me` resolves to the caller's identity. |
-| `supersede <id>` | Replace a note with a new version. Old version stays in git history + index (hidden from recall). |
-| `tag <id> +new -old ...` | Add or remove tags via frontmatter rewrite. Lowercase kebab-case enforced. |
+| `ui` | Open `http://localhost:8080/ui` in your browser. |
+| `open` | Reveal the notes folder in your OS file manager (`open` / `xdg-open` / `explorer`). |
+| `edit <id>` | Open the fact's `.md` in `$EDITOR`; reindexes on save. |
+| `mv <id> <scope>` | Move a note between scopes (id preserved). |
+| `supersede <id>` | Replace a note with a new version. Old stays in git. |
+| `tag <id> +new -old ...` | Add or remove tags via frontmatter rewrite. |
+| `rm <id>` | Delete a fact (file + index + git deletion commit). |
 
-**Team mode** (v0.2.17.1 Phase C)
+**Stop & reset** (v0.2.32+)
 
 | Command | What it does |
 |---|---|
-| `team init` | Admin-side wizard: admin email, team slug, optional git remote, initial teammates. Prints the admin key + per-teammate keys + a copy-paste DM template. |
-| `join --server <url> --key <key>` | Teammate-side: detects editors, writes HTTP MCP config with the bearer header + the standing rule. |
-| `team disband [--yes]` | Per-machine step-back to solo mode: rewrites HTTP MCP entries as stdio. Notes / `members.yaml` / git history untouched. |
+| `stop` | Stop the running krimto (uninstalls/unloads service if installed, SIGTERMs an ad-hoc PID). Plist stays on disk so `start` can reload it. Idempotent. |
+| `start` | Start krimto (re-bootstraps the existing plist). Honest message when no service is configured. |
+| `restart` | `stop` + `start`. Atomic on always-running mode via `launchctl kickstart -k`. |
+| `uninit` | Project-only undo (rule files only). Offers to stop the service too. |
+| `reset [--yes] [--wipe-notes]` | Disconnect every editor (Cursor JSON + Claude Code CLI across user/project/local scopes) + uninstall service + wipe API-key store. `--wipe-notes` collapses to one named-consequence prompt. |
 
-**Change settings** (v0.2.17-4 Phase B)
+**Is it working?**
 
 | Command | What it does |
 |---|---|
-| `editors` | Add or remove editor connections (checkbox prompt with current state preselected). |
-| `search` | Flip between Keyword and OpenAI search. Verifies the OpenAI key before persisting. |
-| `service` | Switch run mode (as-needed / always-running / manual). Installs or uninstalls the platform service. |
-| `reset [--yes] [--wipe-notes]` | Disconnect from all editors + uninstall service + wipe local keys. `--wipe-notes` atomically moves the data dir to a timestamped trash sibling (recoverable). |
+| `status` | One-screen consolidator: running PID + mode + launched-by, editors, storage, add-ons, recent activity, hijack warning. Nudges toward `service --always` when running ad-hoc. |
+| `whoami` | Print the active `KRIMTO_IDENTITY` and every place it's set (each editor's MCP config + the service unit env). Flags mismatches. |
+| `verify-connection` / `where` / `storage` / `usage` | Back-compat aliases — preserve their original stdout, point at `status` on stderr. |
 
-**Diagnose**
+**Configure (after first run)** — every command accepts flags so agents can drive them non-interactively.
 
 | Command | What it does |
 |---|---|
-| `status` | One-screen consolidator (v0.2.17): connections, storage, optional add-ons, recent activity, hijack warning. |
-| `verify-connection` / `where` / `storage` / `usage` | Legacy verbs — still work, point at `status` for the consolidated view. |
-| `setup-remote <url>` | Wire the data dir to a git remote and verify the initial push. |
-| `setup-embeddings` | Send a real test embedding to verify a `KRIMTO_EMBED_*` config. |
+| `editors --add <name> / --remove <name> / --set <list>` | Wire / unwire editors (Cursor / Claude Code / Codex / Gemini). `--list` prints current connections. No-flag form prompts interactively when a TTY is available. |
+| `service --as-needed / --always / --manual` | Switch run mode. Flag form skips the prompt. `service stop` / `service start` are aliases for `stop` / `start`. |
+| `search --keyword / --openai --api-key sk-...` | Switch search provider. The OpenAI path verifies the key before persisting. |
+| `remote --show / --set <url> / --remove` | Manage the git remote (also reachable as `setup-remote <url>`). |
+| `folder --to <path> [--yes]` | Guided move of the data dir. Stops service, atomic rename (cross-fs fallback), reinstalls service with new env, prints `export KRIMTO_DATA=` hint. |
+| `set identity <email>` | Change `KRIMTO_IDENTITY` everywhere atomically (editor MCP configs + service env). Preserves other env keys. |
 
-**Storage**
+**Team**
 
 | Command | What it does |
 |---|---|
-| `rm <id>` | Delete a fact (file + index + git deletion commit). Refuses while a server holds the lock. |
-| `reindex` | Rebuild `index.db` from the markdown files (fixes orphans left by manual `rm` of .md files). |
+| `team init` | Admin-side wizard: admin email, team slug, optional git remote, initial teammates. Prints admin key + per-teammate keys + a DM template. |
+| `team disband [--yes]` | Per-machine step-back to solo mode. Notes / `members.yaml` / git history untouched. |
+| `join --server <url> --key <key>` | Teammate-side: detects editors, writes HTTP MCP config with the bearer header + the standing rule. |
 
-**Other**
+**Advanced / scripting**
 
 | Command | What it does |
 |---|---|
-| (no args) | Start the stdio MCP server (default; for MCP clients to launch) |
-| `--help`, `-h` | Show the full CLI surface |
+| `serve` | Start the HTTP server in the foreground (port 8080) + browser `/ui` dashboard. |
+| `setup-remote <url>` | One-shot git remote setup (verifies the initial push). |
+| `setup-embeddings` | Send a real test embedding to verify a `KRIMTO_EMBED_*` config. |
+| `reindex` | Rebuild `index.db` from markdown (fixes orphans). |
+| `delete <id>` | Alias for `rm`. |
+| (no args) | Start the stdio MCP server (default; for MCP clients to launch). |
+| `--help`, `-h` | Show the full CLI surface — includes a `For AI agents (no TTY)` block at the top with copy-paste flag examples. |
 
 The stdio entrypoint enforces a **single-writer lock** on the data dir (`.krimto/lock.json`) — two
 Krimto processes can no longer race on the same `~/.krimto`. A second `serve`/stdio launch is

package/bin/krimto.mjs

@@ -6,6 +6,24 @@
 import process from "node:process";
 import { tsImport } from "tsx/esm/api";
 
+/**
+ * v0.2.34 — collect every value passed via a repeating flag. Used by `editors --add cursor
+ * --add codex` and similar. Accepts both `--flag value` and `--flag=value` forms; ignores
+ * the flag itself.
+ */
+function collectFlagValues(flags, name) {
+  const values = [];
+  for (let i = 0; i < flags.length; i++) {
+    const f = flags[i];
+    if (f === name) {
+      if (typeof flags[i + 1] === "string") values.push(flags[i + 1]);
+    } else if (typeof f === "string" && f.startsWith(`${name}=`)) {
+      values.push(f.slice(name.length + 1));
+    }
+  }
+  return values;
+}
+
 try {
   // Two-word command support (v0.2.17.1): `team init`, `team disband`. Collapse argv[2]+argv[3]
   // into one cmd string when argv[2] is one of the namespaced verbs.
@@ -363,16 +381,84 @@ try {
     process.stderr.write("\n→ `krimto verify-connection` is now part of `krimto status` (one command, four answers).\n");
     if (result.status === "none") process.exitCode = 1;
   } else if (cmd === "editors") {
-    // `krimto editors` — one-question shortcut to add/remove editor connections (Phase B).
-    const { runEditors } = await tsImport("../src/cli/editors.ts", import.meta.url);
-    const result = await runEditors();
-    if (result === null) process.exitCode = 1;
+    // `krimto editors` — Phase B shortcut. v0.2.34 added flag forms for AI-agent + CI use:
+    //   --add <name>       Connect one editor (merge with current set). Repeatable.
+    //   --remove <name>    Disconnect one editor (merge with current set). Repeatable.
+    //   --set <list>       Replace the entire connected set (comma-separated).
+    //   --list             Print current connected editors, one per line.
+    // No flags + TTY → interactive checkbox wizard (unchanged).
+    // No flags + no TTY → the new assertInteractiveOrUsage guard prints flag usage and exits 2.
+    const flags = process.argv.slice(3);
+    if (flags.includes("--list")) {
+      const { listConnectedEditors } = await tsImport("../src/cli/editors.ts", import.meta.url);
+      const connected = await listConnectedEditors();
+      for (const e of connected) process.stdout.write(`${e}\n`);
+    } else {
+      const adds = collectFlagValues(flags, "--add");
+      const removes = collectFlagValues(flags, "--remove");
+      const setIdx = flags.indexOf("--set");
+      const setValue = setIdx >= 0 ? flags[setIdx + 1] : undefined;
+      const yes = flags.includes("--yes");
+      const { runEditors, parseEditorList, listConnectedEditors } = await tsImport(
+        "../src/cli/editors.ts",
+        import.meta.url,
+      );
+      if (adds.length > 0 || removes.length > 0 || setValue !== undefined) {
+        // Programmatic path — compute the target set and call applyEditors directly through
+        // the wrapper. `editors` option short-circuits the prompt.
+        let target;
+        try {
+          if (setValue !== undefined) {
+            target = parseEditorList([setValue]);
+          } else {
+            const current = await listConnectedEditors();
+            const toAdd = parseEditorList(adds);
+            const toRemove = new Set(parseEditorList(removes));
+            target = [...current];
+            for (const a of toAdd) if (!target.includes(a)) target.push(a);
+            target = target.filter((e) => !toRemove.has(e));
+          }
+        } catch (err) {
+          process.stderr.write(`krimto editors: ${err instanceof Error ? err.message : String(err)}\n`);
+          process.exit(2);
+        }
+        const result = await runEditors({ editors: target, ...(yes ? { yes: true } : {}) });
+        if (result === null) process.exitCode = 1;
+      } else {
+        // No flags — TTY user gets the interactive checkbox; agents get the guard's usage.
+        const result = await runEditors();
+        if (result === null) process.exitCode = 1;
+      }
+    }
   } else if (cmd === "search") {
     // `krimto search` — change the search provider (Keyword vs OpenAI) without re-running the
-    // whole setup wizard (Phase B).
+    // whole setup wizard (Phase B). v0.2.34 added flag forms for agent / CI use:
+    //   --keyword                   Switch to keyword search (default, no API key).
+    //   --openai --api-key sk-...   Switch to OpenAI semantic search (key verified first).
+    // No flags + TTY → interactive select; no flags + no TTY → guard prints usage + exit 2.
+    const flags = process.argv.slice(3);
+    const keyword = flags.includes("--keyword");
+    const openai = flags.includes("--openai");
+    const apiKeyIdx = flags.indexOf("--api-key");
+    const keyIdx = flags.indexOf("--key");
+    const apiKey =
+      apiKeyIdx >= 0 ? flags[apiKeyIdx + 1] : keyIdx >= 0 ? flags[keyIdx + 1] : undefined;
     const { runSearchSettings } = await tsImport("../src/cli/searchSettings.ts", import.meta.url);
-    const result = await runSearchSettings();
-    if (result === null) process.exitCode = 1;
+    if (keyword) {
+      const result = await runSearchSettings({ provider: "keyword" });
+      if (result === null) process.exitCode = 1;
+    } else if (openai) {
+      if (!apiKey) {
+        process.stderr.write("krimto search --openai requires --api-key <sk-...>\n");
+        process.exit(2);
+      }
+      const result = await runSearchSettings({ provider: "openai", apiKey });
+      if (result === null) process.exitCode = 1;
+    } else {
+      // No flags — TTY user gets the interactive select; agents get the guard's usage.
+      const result = await runSearchSettings();
+      if (result === null) process.exitCode = 1;
+    }
   } else if (cmd === "service") {
     // `krimto service` — change run mode (as-needed / always-running / manual). Installs or
     // uninstalls the platform service to match (Phase B). v0.2.32: accepts `--as-needed`,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@krimto-labs/krimto",
-  "version": "0.2.32",
+  "version": "0.2.35",
   "description": "Open-source team memory layer for AI agents — markdown files in git, user/team/org hierarchy, cross-vendor MCP server.",
   "license": "Apache-2.0",
   "type": "module",

package/src/cli/editors.ts

@@ -24,7 +24,7 @@ import {
   writeMcpConfig,
   type WriteAction,
 } from "./mcpConfig";
-import { defaultIO, isExitPrompt, type WizardIO } from "./promptHelpers";
+import { assertInteractiveOrUsage, defaultIO, isExitPrompt, type WizardIO } from "./promptHelpers";
 
 const EDITOR_LABEL: Record<EditorKind, string> = {
   cursor: "Cursor",
@@ -89,6 +89,13 @@ export async function applyEditors(
 
 export async function runEditors(opts: EditorsOptions = {}): Promise<EditorsResult | null> {
   const io = opts.io ?? defaultIO;
+  // v0.2.34 — when no editor list was supplied programmatically, we'd open the checkbox
+  // prompt. Without a TTY (AI-agent Bash, CI) that prompt would hang then crash with the
+  // cryptic "unsettled top-level await" warning. Detect and surface the right flags
+  // instead, so agents get a clean exit + actionable usage.
+  if (!opts.editors) {
+    assertInteractiveOrUsage(EDITORS_USAGE);
+  }
   try {
     const cwd = opts.cwd ?? process.cwd();
     const envs = await detectEditorEnvironments(cwd, opts.homeDir);
@@ -114,6 +121,62 @@ export async function runEditors(opts: EditorsOptions = {}): Promise<EditorsResu
   }
 }
 
+/** Non-interactive usage shown by the TTY guard when an agent runs `krimto editors` cold. */
+const EDITORS_USAGE =
+  "For non-interactive use (AI agents / CI):\n" +
+  "  krimto editors --add cursor [--yes]            Connect one editor (repeat or comma-list ok)\n" +
+  "  krimto editors --remove cursor [--yes]         Disconnect one editor\n" +
+  "  krimto editors --set cursor,claude-code [--yes]  Replace the full connected set\n" +
+  "  krimto editors --list                          Print current connections (one per line)";
+
+/**
+ * v0.2.34 — parse a comma-separated / repeated CLI value into a deduped EditorKind list.
+ * Accepts the canonical slugs plus common variants. Throws (with a clear message) on
+ * unknown names so an agent passing a typo learns immediately instead of silently no-op'ing.
+ */
+export function parseEditorList(values: string[]): EditorKind[] {
+  const aliases: Record<string, EditorKind> = {
+    cursor: "cursor",
+    "claude-code": "claude-code",
+    claudecode: "claude-code",
+    claude_code: "claude-code",
+    claude: "claude-code",
+    codex: "codex",
+    gemini: "gemini-cli",
+    "gemini-cli": "gemini-cli",
+    geminicli: "gemini-cli",
+  };
+  const out: EditorKind[] = [];
+  const seen = new Set<EditorKind>();
+  for (const raw of values) {
+    for (const part of raw.split(",").map((s) => s.trim()).filter(Boolean)) {
+      const key = part.toLowerCase();
+      const kind = aliases[key];
+      if (!kind) {
+        throw new Error(
+          `Unknown editor "${part}". Expected one of: cursor, claude-code, codex, gemini-cli.`,
+        );
+      }
+      if (!seen.has(kind)) {
+        out.push(kind);
+        seen.add(kind);
+      }
+    }
+  }
+  return out;
+}
+
+/**
+ * v0.2.34 — programmatic helpers the bin uses to compute the target editor set without
+ * spawning the checkbox prompt. `--add` / `--remove` are merge ops over the current
+ * snapshot; `--set` replaces the list outright.
+ */
+export async function listConnectedEditors(opts: { cwd?: string; homeDir?: string } = {}): Promise<EditorKind[]> {
+  const cwd = opts.cwd ?? process.cwd();
+  const snapshot = await detectExistingSetup(cwd, opts.homeDir);
+  return snapshot.registeredEditors;
+}
+
 async function askEditorsList(
   envs: EditorEnvironment[],
   current: EditorKind[],

package/src/cli/folderCmd.ts

@@ -27,7 +27,7 @@ import {
   type InstallResult,
 } from "./service";
 import { defaultIdentity } from "./init";
-import { defaultIO, isExitPrompt, type WizardIO } from "./promptHelpers";
+import { assertInteractiveOrUsage, defaultIO, isExitPrompt, type WizardIO } from "./promptHelpers";
 
 export interface FolderCmdOptions {
   io?: WizardIO;
@@ -56,6 +56,12 @@ export async function runFolderCmd(opts: FolderCmdOptions): Promise<FolderCmdRes
   const io = opts.io ?? defaultIO;
   const fromDir = path.resolve(opts.from);
 
+  // v0.2.34 — when --to was NOT supplied we'd open an input prompt for the destination.
+  // Without a TTY (AI agent / CI) that hangs. Surface the flag form.
+  if (!opts.to) {
+    assertInteractiveOrUsage(FOLDER_USAGE);
+  }
+
   try {
     io.out("\nKrimto — Move the notes folder\n\n");
     io.out(`  Current location:  ${fromDir}\n\n`);
@@ -214,3 +220,8 @@ async function classifyDestination(dir: string): Promise<"absent" | "empty" | "n
     return "non-empty";
   }
 }
+
+/** v0.2.34 — non-interactive usage shown by the TTY guard. */
+const FOLDER_USAGE =
+  "For non-interactive use (AI agents / CI):\n" +
+  "  krimto folder --to /new/absolute/path --yes   Move the notes folder";

package/src/cli/help.ts

@@ -19,6 +19,20 @@ export function formatHelp(version: string): string {
     "  AUTO MODE     Your agent uses Krimto automatically (no prefix needed).",
     "                Setup: `init` walks the whole flow in one command.",
     "",
+    "━━ For AI agents (no TTY) ━━",
+    "",
+    "  Setting Krimto up programmatically? Most commands accept flags so you can",
+    "  skip the interactive prompts. The canonical one-shot for a full install:",
+    "",
+    "    $ krimto init --yes                                Full setup, all defaults",
+    "    $ krimto status                                    Machine-readable check (stdout)",
+    "    $ krimto editors --add cursor [--yes]              Wire one editor",
+    "    $ krimto service --always | --as-needed | --manual  Switch run mode",
+    "    $ krimto search --keyword | --openai --api-key sk-...",
+    "    $ krimto stop / start / restart                    Service control (idempotent)",
+    "",
+    "  Interactive commands without flags will exit 2 with usage instead of hanging.",
+    "",
     "━━ Usage ━━",
     "",
     "  $ npx @krimto-labs/krimto [command]",

package/src/cli/mcpConfig.ts

@@ -148,25 +148,62 @@ export async function writeMcpConfig(
  * matching `mcp remove`, but we don't depend on it).
  */
 export async function removeMcpConfig(env: EditorEnvironment): Promise<{ removed: boolean }> {
-  if (env.mcpWire === null || env.mcpWire.method !== "json") return { removed: false };
-  let text: string;
-  try {
-    text = await fs.readFile(env.mcpWire.path, "utf8");
-  } catch {
-    return { removed: false };
+  if (env.mcpWire === null) return { removed: false };
+
+  if (env.mcpWire.method === "json") {
+    let text: string;
+    try {
+      text = await fs.readFile(env.mcpWire.path, "utf8");
+    } catch {
+      return { removed: false };
+    }
+    let parsed: Record<string, unknown>;
+    try {
+      parsed = JSON.parse(text) as Record<string, unknown>;
+    } catch {
+      return { removed: false };
+    }
+    const servers = parsed[env.mcpWire.key] as Record<string, unknown> | undefined;
+    if (!servers || !("krimto" in servers)) return { removed: false };
+    const { krimto: _krimto, ...rest } = servers; // eslint-disable-line @typescript-eslint/no-unused-vars
+    parsed[env.mcpWire.key] = rest;
+    await fs.writeFile(env.mcpWire.path, JSON.stringify(parsed, null, 2) + "\n", "utf8");
+    return { removed: true };
   }
-  let parsed: Record<string, unknown>;
-  try {
-    parsed = JSON.parse(text) as Record<string, unknown>;
-  } catch {
-    return { removed: false };
+
+  // v0.2.35 — CLI method (Claude Code). The smoke-6 transcript caught reset reporting "No
+  // editors were connected" while `claude mcp list` still showed krimto. Root cause: this
+  // function used to bail at the top with `method !== "json"`, so the CLI path was never
+  // exercised. The reset SWEEP rule (always run cleanup, never trust detection) covers the
+  // intent here too — we shell out to `claude mcp remove krimto` across the three scopes
+  // Claude Code supports (local / user / project). Each call is idempotent: if krimto
+  // isn't registered at a scope, claude prints "MCP server krimto not found" and exits
+  // non-zero, which we swallow. We mark removed=true when ANY scope succeeds.
+  if (env.mcpWire.method === "cli") {
+    return { removed: await removeClaudeMcpAllScopes(env.mcpWire.command) };
+  }
+
+  return { removed: false };
+}
+
+/**
+ * v0.2.35 — try `claude mcp remove krimto -s <scope>` for each known scope. Returns true
+ * when at least one succeeds. The user's krimto entry may live in any scope depending on
+ * which directory they were in when they originally ran `claude mcp add`, so we sweep all
+ * three. Errors are best-effort (no-op when nothing's registered at that scope).
+ */
+async function removeClaudeMcpAllScopes(claudeBinary: string): Promise<boolean> {
+  const scopes = ["local", "user", "project"] as const;
+  let anyRemoved = false;
+  for (const scope of scopes) {
+    try {
+      await exec(claudeBinary, ["mcp", "remove", "krimto", "-s", scope]);
+      anyRemoved = true;
+    } catch {
+      // "MCP server krimto not found" at this scope — fine, try the next.
+    }
   }
-  const servers = parsed[env.mcpWire.key] as Record<string, unknown> | undefined;
-  if (!servers || !("krimto" in servers)) return { removed: false };
-  const { krimto: _krimto, ...rest } = servers; // eslint-disable-line @typescript-eslint/no-unused-vars
-  parsed[env.mcpWire.key] = rest;
-  await fs.writeFile(env.mcpWire.path, JSON.stringify(parsed, null, 2) + "\n", "utf8");
-  return { removed: true };
+  return anyRemoved;
 }
 
 // --- internal helpers -------------------------------------------------------

package/src/cli/promptHelpers.ts

@@ -22,3 +22,27 @@ export const defaultIO: WizardIO = {
 export function isExitPrompt(e: unknown): boolean {
   return e instanceof Error && e.name === "ExitPromptError";
 }
+
+/**
+ * v0.2.34 — guard for the Phase B commands (`editors`, `service`, `search`, `reset`,
+ * `remote`, `folder`) when about to spawn an `@inquirer/prompts` UI. If the process has no
+ * TTY on stdin (typical for an AI-agent shell tool), the prompt would hang forever, then
+ * Node would surface the cryptic "Detected unsettled top-level await" warning and abort.
+ *
+ * Instead, we detect the no-TTY case here, print a copy-pasteable usage block, and exit
+ * 2 cleanly. The TTY case is a no-op — the interactive wizard runs as before. Each caller
+ * supplies its own `usage` text naming the flags an agent should use.
+ *
+ * NOTE: this is only called BEFORE the first prompt would run. When a flag like
+ * `--always` / `--add cursor` / `--keyword` IS passed, the caller skips the prompt entirely
+ * and never invokes this — the non-interactive path stays open.
+ */
+export function assertInteractiveOrUsage(usage: string): void {
+  if (process.stdin.isTTY === true) return;
+  process.stderr.write(
+    "\nℹ️  No interactive terminal detected — this command needs flags for non-interactive use.\n\n" +
+      usage +
+      "\n\nSee `krimto --help` for the full list.\n",
+  );
+  process.exit(2);
+}

package/src/cli/remoteCmd.ts

@@ -10,7 +10,7 @@ import { promisify } from "node:util";
 
 import { readDataDirGitInfo } from "../storage/git";
 import { runSetupRemote, type SetupRemoteResult } from "./setupRemote";
-import { defaultIO, isExitPrompt, type WizardIO } from "./promptHelpers";
+import { assertInteractiveOrUsage, defaultIO, isExitPrompt, type WizardIO } from "./promptHelpers";
 
 const exec = promisify(execFile);
 
@@ -40,6 +40,12 @@ export async function runRemoteCmd(opts: RemoteCmdOptions): Promise<RemoteCmdRes
   const io = opts.io ?? defaultIO;
   const dataDir = opts.dataDir;
 
+  // v0.2.34 — guard against agents calling `krimto remote` cold. Without an action
+  // we open a select prompt; without a TTY that hangs. Surface the flag forms.
+  if (!opts.action) {
+    assertInteractiveOrUsage(REMOTE_USAGE);
+  }
+
   try {
     const gitInfo = await readDataDirGitInfo(dataDir);
     const current = gitInfo.remote;
@@ -137,3 +143,10 @@ export async function runRemoteCmd(opts: RemoteCmdOptions): Promise<RemoteCmdRes
     throw e;
   }
 }
+
+/** v0.2.34 — non-interactive usage shown by the TTY guard. */
+const REMOTE_USAGE =
+  "For non-interactive use (AI agents / CI):\n" +
+  "  krimto remote --show                          Print the current remote URL\n" +
+  "  krimto remote --set git@host:repo.git         Wire a remote (verifies the first push)\n" +
+  "  krimto remote --remove --yes                  Unwire the remote";

package/src/cli/reset.ts

@@ -24,7 +24,7 @@ import {
   type EditorKind,
 } from "./init";
 import { removeMcpConfig } from "./mcpConfig";
-import { defaultIO, isExitPrompt, type WizardIO } from "./promptHelpers";
+import { assertInteractiveOrUsage, defaultIO, isExitPrompt, type WizardIO } from "./promptHelpers";
 import { detectPlatform, uninstallService } from "./service";
 
 const EDITOR_LABEL: Record<EditorKind, string> = {
@@ -152,41 +152,50 @@ export async function applyReset(opts: ResetOptions = {}): Promise<ResetResult>
 
 export async function runReset(opts: ResetOptions = {}): Promise<ResetResult | null> {
   const io = opts.io ?? defaultIO;
+  // v0.2.34 — when --yes was NOT passed we'd open a confirm prompt. Without a TTY (AI
+  // agent / CI) the prompt would hang. Surface the flag form instead.
+  if (!opts.yes) {
+    assertInteractiveOrUsage(RESET_USAGE);
+  }
   try {
     const dataDir = opts.dataDir ?? path.join(opts.homeDir ?? "", ".krimto");
 
+    // v0.2.33 — single-prompt UX. The original flow asked "Proceed with reset?" first
+    // (default N), and only AFTER that asked the wipe-notes-specific confirmation. Users
+    // who passed `--wipe-notes` were tripped up by the first prompt: they'd typed the flag,
+    // hit Enter at "Proceed?", and got "No changes made" without realising the flag they
+    // passed had no consent baked in. The fix: when `--wipe-notes` is passed, collapse the
+    // two confirmations into ONE that names the worst thing explicitly. Without the flag,
+    // the single-prompt flow stays exactly as it was.
     io.out("\nKrimto — Reset machine-level config\n\n");
-    io.out("  This will:\n");
-    io.out("    • Disconnect Krimto from all editors (MCP config + standing rule)\n");
-    io.out("    • Stop and uninstall the background service (if installed)\n");
-    io.out("    • Wipe the local API-key store\n\n");
-    io.out("  This will NOT touch:\n");
-    io.out(`    • Your notes folder (${dataDir}) — unless you pass --wipe-notes\n`);
-    io.out("    • The team's git history or members.yaml\n\n");
+    if (opts.wipeNotes) {
+      io.out("  ⚠️  --wipe-notes — this will:\n");
+      io.out("    • Disconnect Krimto from all editors (MCP config + standing rule)\n");
+      io.out("    • Stop and uninstall the background service (if installed)\n");
+      io.out("    • Wipe the local API-key store\n");
+      io.out(`    • MOVE your notes folder (${dataDir}) to a timestamped trash sibling\n`);
+      io.out(`      ${dataDir}.trash-<ts> stays on disk until you delete it manually.\n\n`);
+      io.out("  This will NOT touch:\n");
+      io.out("    • The team's git history or members.yaml on the remote\n\n");
+    } else {
+      io.out("  This will:\n");
+      io.out("    • Disconnect Krimto from all editors (MCP config + standing rule)\n");
+      io.out("    • Stop and uninstall the background service (if installed)\n");
+      io.out("    • Wipe the local API-key store\n\n");
+      io.out("  This will NOT touch:\n");
+      io.out(`    • Your notes folder (${dataDir}) — pass --wipe-notes to also move it\n`);
+      io.out("    • The team's git history or members.yaml\n\n");
+    }
 
-    const ok = opts.yes ?? (await confirm({ message: "Proceed with reset?", default: false }));
+    const promptMessage = opts.wipeNotes
+      ? "Wipe notes folder AND disconnect everything?"
+      : "Proceed with reset?";
+    const ok = opts.yes ?? (await confirm({ message: promptMessage, default: false }));
     if (!ok) {
       io.out("\nNo changes made.\n");
       return null;
     }
 
-    // The --wipe-notes path needs its OWN confirmation — the default reset is reversible
-    // (just re-run `krimto init`), but wiping notes is data loss.
-    if (opts.wipeNotes && !opts.yes) {
-      io.out(
-        `\n⚠️  --wipe-notes will MOVE ${dataDir} to a timestamped trash sibling.\n` +
-          `   The notes stay on disk (recoverable) until you delete the trash dir manually.\n`,
-      );
-      const wipeOk = await confirm({
-        message: `Confirm: also move ${dataDir} to ${dataDir}.trash-<ts>?`,
-        default: false,
-      });
-      if (!wipeOk) {
-        io.out("\n(Reset proceeding without --wipe-notes — notes preserved.)\n");
-        opts = { ...opts, wipeNotes: false };
-      }
-    }
-
     const result = await applyReset(opts);
     printResetResult(result, io);
     return result;
@@ -272,3 +281,9 @@ function printResetResult(res: ResetResult, io: WizardIO): void {
   }
   io.out("\nRestart your editor(s) so they pick up the changes.\n");
 }
+
+/** v0.2.34 — non-interactive usage shown by the TTY guard. */
+const RESET_USAGE =
+  "For non-interactive use (AI agents / CI):\n" +
+  "  krimto reset --yes                            Disconnect everything (notes preserved)\n" +
+  "  krimto reset --yes --wipe-notes               Also MOVE notes to a trash sibling";

package/src/cli/searchSettings.ts

@@ -14,7 +14,7 @@ import {
   detectExistingSetup,
   type SearchProvider,
 } from "./init";
-import { defaultIO, isExitPrompt, type WizardIO } from "./promptHelpers";
+import { assertInteractiveOrUsage, defaultIO, isExitPrompt, type WizardIO } from "./promptHelpers";
 import { runSetupEmbeddings } from "./setupEmbeddings";
 
 export interface SearchOptions {
@@ -83,6 +83,11 @@ export async function applySearch(
 
 export async function runSearchSettings(opts: SearchOptions = {}): Promise<SearchResult | null> {
   const io = opts.io ?? defaultIO;
+  // v0.2.34 — when no provider was supplied programmatically we'd open a select prompt.
+  // Without a TTY (AI agent / CI) that prompt hangs. Surface the flag form instead.
+  if (!opts.provider) {
+    assertInteractiveOrUsage(SEARCH_USAGE);
+  }
   try {
     const snapshot = await detectExistingSetup(opts.cwd ?? process.cwd(), opts.homeDir);
     io.out("\nKrimto — Search settings\n\n");
@@ -145,3 +150,10 @@ export async function runSearchSettings(opts: SearchOptions = {}): Promise<Searc
     throw e;
   }
 }
+
+/** Non-interactive usage shown by the v0.2.34 TTY guard. */
+const SEARCH_USAGE =
+  "For non-interactive use (AI agents / CI):\n" +
+  "  krimto search --keyword                       Use keyword search (default, free)\n" +
+  "  krimto search --openai --api-key sk-...       Use OpenAI semantic search (key verified)";
+

package/src/cli/serviceCmd.ts

@@ -18,7 +18,7 @@ import {
   type UninstallResult,
 } from "./service";
 import { defaultIdentity, type RunMode } from "./init";
-import { defaultIO, isExitPrompt, type WizardIO } from "./promptHelpers";
+import { assertInteractiveOrUsage, defaultIO, isExitPrompt, type WizardIO } from "./promptHelpers";
 
 export interface ServiceCmdOptions {
   io?: WizardIO;
@@ -75,6 +75,12 @@ export async function applyService(
 
 export async function runServiceCmd(opts: ServiceCmdOptions = {}): Promise<ServiceCmdResult | null> {
   const io = opts.io ?? defaultIO;
+  // v0.2.34 — guard against agents calling `krimto service` cold. Without a mode flag we
+  // would spawn a select prompt; without a TTY that hangs and then crashes with "unsettled
+  // top-level await". Surface the flag forms instead.
+  if (!opts.mode) {
+    assertInteractiveOrUsage(SERVICE_USAGE);
+  }
   try {
     const platform = detectPlatform();
     const current = await isServiceInstalled(platform, opts.homeDir);
@@ -144,3 +150,10 @@ function runModeLabel(m: RunMode): string {
       return "Manual (`krimto serve`)";
   }
 }
+
+/** v0.2.34 — non-interactive usage shown by the TTY guard. */
+const SERVICE_USAGE =
+  "For non-interactive use (AI agents / CI):\n" +
+  "  krimto service --as-needed                    Editor launches Krimto on demand (stdio)\n" +
+  "  krimto service --always                       Run continuously as a background service\n" +
+  "  krimto service --manual                       Don't auto-start; user runs `krimto serve`";

package/src/cli/status.ts

@@ -134,9 +134,20 @@ function headerLine(
 ): string {
   if (status === "ok") {
     if (lock?.alive) {
-      return `\n✅ Krimto is working · v${KRIMTO_VERSION}\n   PID ${lock.info.pid} (${lock.info.mode}, ${effectiveLaunchedBy ?? lock.info.launchedBy}), started ${humanAgo(lock.info.started, now)}\n`;
+      // v0.2.34 — when the running process is ad-hoc (a foreground `krimto serve` or an
+      // editor's stdio launcher), nudge the user toward `krimto service --always` so the
+      // service survives reboots without them having to dig for the verb.
+      const adHocHint =
+        (effectiveLaunchedBy ?? lock.info.launchedBy) === "service"
+          ? ""
+          : "   → To run continuously across reboots: krimto service --always\n";
+      return `\n✅ Krimto is working · v${KRIMTO_VERSION}\n   PID ${lock.info.pid} (${lock.info.mode}, ${effectiveLaunchedBy ?? lock.info.launchedBy}), started ${humanAgo(lock.info.started, now)}\n${adHocHint}`;
     }
-    return `\n✅ Krimto is configured · v${KRIMTO_VERSION}\n   No active server right now — it will be launched on demand by your editor.\n`;
+    return (
+      `\n✅ Krimto is configured · v${KRIMTO_VERSION}\n` +
+      `   No active server right now — it will be launched on demand by your editor.\n` +
+      `   → To run continuously across reboots: krimto service --always\n`
+    );
   }
   if (status === "warning") {
     return `\n⚠️  Krimto needs attention · v${KRIMTO_VERSION}\n`;

package/src/cli/wizard.ts

@@ -25,6 +25,10 @@ import {
 } from "./init";
 import { runSetupEmbeddings } from "./setupEmbeddings";
 import { KRIMTO_VERSION } from "../server/index";
+import { inspectRuntime, type RuntimeState } from "./inspectRuntime";
+import { applyService } from "./serviceCmd";
+import * as os from "node:os";
+import * as path from "node:path";
 
 const EDITOR_LABEL: Record<EditorKind, string> = {
   cursor: "Cursor",
@@ -68,46 +72,88 @@ export async function runInitWizard(
   }
 }
 
-/** §06 — "Krimto is already set up on this machine. What would you like to do?" */
+/**
+ * §06 — reconfigure menu shown when `krimto init` is re-run on a configured machine.
+ *
+ * v0.2.35: drops the ambiguous "Krimto is already set up on this machine" header (users
+ * read "set up" as "running"). The new header is neutral — "Krimto on this machine:" —
+ * and adds a real **Service:** line driven by `inspectRuntime` (config-snapshot ≠ runtime).
+ * That way the user always knows whether a process is actually serving right now, not just
+ * whether a config exists on disk. A fifth menu choice — "Start it running continuously"
+ * — appears only when no service is currently loaded, so users who want a daemon find the
+ * button without leaving the menu.
+ */
 async function runReconfigureMenu(
   cwd: string,
   snapshot: SetupSnapshot,
   opts: RunWizardOptions,
   io: WizardIO,
 ): Promise<ApplyResult | null> {
+  // Match applyWizardAnswers's pattern: derive dataDir from homeDir when not explicitly
+  // passed. Tests rely on this so the runtime probe hits a test temp dir, not the user's
+  // real ~/.krimto.
+  const homeDir = opts.homeDir ?? os.homedir();
+  const dataDir = opts.dataDir ?? path.join(homeDir, ".krimto");
+  const runtime = await inspectRuntime(dataDir, { cwd, homeDir });
+
   io.out("\n");
-  io.out("Krimto is already set up on this machine.\n");
-  io.out(`  Editors:   ${snapshot.registeredEditors.map((e) => EDITOR_LABEL[e]).join(", ") || "(none)"}\n`);
-  io.out(`  Run mode:  ${runModeLabel(snapshot.runMode)}\n`);
+  io.out("Krimto on this machine:\n");
+  io.out(
+    `  Editors:   ${
+      snapshot.registeredEditors.map((e) => EDITOR_LABEL[e]).join(", ") || "(none)"
+    }\n`,
+  );
+  io.out(`  Service:   ${formatServiceLine(runtime)}\n`);
   io.out(`  Search:    ${searchLabel(snapshot.searchProvider)}\n`);
   io.out("\n");
 
+  // The "Start it running continuously" choice only makes sense when no daemon is alive.
+  // (When already running as a service, there's nothing to start; when running ad-hoc, the
+  // user is better served by `krimto service --always` AFTER stopping the ad-hoc one, which
+  // is more state than this menu wants to manage.)
+  const canStartService =
+    !runtime.service.loaded && !(runtime.lock?.alive ?? false);
+
+  const choices: Array<{
+    value: "refresh" | "reconfigure" | "status" | "start-service" | "quit";
+    name: string;
+    description: string;
+  }> = [
+    {
+      value: "refresh",
+      name: "Just refresh the standing rule in this project",
+      description:
+        "Re-applies the 'always use Krimto' rule to CLAUDE.md / .cursor/rules/ here.\nUse this when you just cloned a new repo.",
+    },
+    {
+      value: "reconfigure",
+      name: "Change settings (reconfigure)",
+      description:
+        "Re-runs the setup wizard with your current answers pre-filled.\nSkip anything you don't want to change.",
+    },
+    {
+      value: "status",
+      name: "View status",
+      description: "Show what's working, what's configured, recent activity.",
+    },
+  ];
+  if (canStartService) {
+    choices.push({
+      value: "start-service",
+      name: "Start it running continuously (install as a background service)",
+      description:
+        "Runs Krimto as a launchd / systemd-user / schtasks service so it stays up\nacross reboots. Equivalent to `krimto service --always`.",
+    });
+  }
+  choices.push({
+    value: "quit",
+    name: "Quit",
+    description: "Leave Krimto as it is.",
+  });
+
   const choice = await select({
     message: "What would you like to do?",
-    choices: [
-      {
-        value: "refresh" as const,
-        name: "Just refresh the standing rule in this project",
-        description:
-          "Re-applies the 'always use Krimto' rule to CLAUDE.md / .cursor/rules/ here.\nUse this when you just cloned a new repo.",
-      },
-      {
-        value: "reconfigure" as const,
-        name: "Change settings (reconfigure)",
-        description:
-          "Re-runs the setup wizard with your current answers pre-filled.\nSkip anything you don't want to change.",
-      },
-      {
-        value: "status" as const,
-        name: "View status",
-        description: "Show what's working, what's configured, recent activity.",
-      },
-      {
-        value: "quit" as const,
-        name: "Quit",
-        description: "Leave Krimto as it is.",
-      },
-    ],
+    choices,
   });
 
   if (choice === "quit") {
@@ -139,10 +185,70 @@ async function runReconfigureMenu(
     return null;
   }
 
+  if (choice === "start-service") {
+    // v0.2.35 — install + load the always-running service from inside the menu so users
+    // who want a daemon don't have to drop back to the shell and remember the flag name.
+    // Delegates to applyService which handles the platform-specific install + port probe.
+    io.out("\nInstalling background service...\n");
+    const installResult = await applyService("always-running", {
+      ...(opts.dataDir ? { dataDir: opts.dataDir } : {}),
+      ...(opts.homeDir ? { homeDir: opts.homeDir } : {}),
+      ...(opts.dryRun ? { dryRun: true } : {}),
+    });
+    if (installResult.install?.activated) {
+      const portMsg =
+        installResult.install.portReady === false
+          ? "  ⚠ Service installed but the HTTP port didn't come up within 10s. Check\n    /tmp/com.krimto.server.err.log.\n"
+          : "  ✓ Service started, port accepting connections.\n";
+      io.out("\n✅ Background service is now running.\n" + portMsg + "\n");
+    } else {
+      io.out("\n(Service was configured but not activated — likely a dry-run.)\n");
+    }
+    return null;
+  }
+
   // "reconfigure" — re-run the five questions with snapshot as defaults
   return runFreshWizard(cwd, opts, io, snapshot);
 }
 
+/**
+ * v0.2.35 — turn the reconciled runtime view into one human line for the reconfigure menu.
+ * Four cases (in priority order):
+ *   1. A live process holds the lock AND launched-by="service"   → "Running as background service (PID …, started Nm ago)"
+ *   2. A live process holds the lock, launched-by="ad-hoc"        → "Running ad-hoc (PID … — started by `krimto serve` or an editor)"
+ *   3. Service unit on disk but not loaded                        → "⚠ Installed but not running — `krimto start` to load it"
+ *   4. Nothing running, no unit on disk                            → "Not running (your editor launches it on demand via stdio)"
+ *
+ * This is the line that the smoke-6 user wanted: "is Krimto serving RIGHT NOW?" — driven
+ * by lock + launchctl/systemctl reality, not by the static config snapshot.
+ */
+function formatServiceLine(runtime: RuntimeState): string {
+  const lock = runtime.lock;
+  if (lock?.alive) {
+    const ago = humanAgoForLock(lock.started);
+    if (runtime.effectiveLaunchedBy === "service") {
+      return `Running as background service (PID ${lock.pid}, started ${ago})`;
+    }
+    return `Running ad-hoc (PID ${lock.pid} — started ${ago} by \`krimto serve\` or an editor)`;
+  }
+  if (runtime.service.installed) {
+    return "⚠ Installed but not running — `krimto start` to load it";
+  }
+  return "Not running (your editor launches it on demand via stdio)";
+}
+
+function humanAgoForLock(iso: string): string {
+  const t = Date.parse(iso);
+  if (Number.isNaN(t)) return iso;
+  const secs = Math.max(0, Math.round((Date.now() - t) / 1000));
+  if (secs < 60) return `${secs}s ago`;
+  const mins = Math.round(secs / 60);
+  if (mins < 60) return `${mins}m ago`;
+  const hrs = Math.round(mins / 60);
+  if (hrs < 24) return `${hrs}h ago`;
+  return `${Math.round(hrs / 24)}d ago`;
+}
+
 /** §03 — the fresh five-question flow. `snapshot` (when given) seeds the defaults. */
 async function runFreshWizard(
   cwd: string,

package/src/server/index.ts

@@ -49,7 +49,7 @@ import { type Requester } from "../access/scope";
 
 export type RequesterResolver = (extra: { authInfo?: AuthInfo }) => Requester;
 
-export const KRIMTO_VERSION = "0.2.32";
+export const KRIMTO_VERSION = "0.2.35";
 
 export function resolveDataDir(): string {
   return process.env.KRIMTO_DATA ?? path.join(homedir(), ".krimto");