@krimto-labs/krimto 0.2.34 → 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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@krimto-labs/krimto",
-  "version": "0.2.34",
+  "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/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/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.34";
+export const KRIMTO_VERSION = "0.2.35";
 
 export function resolveDataDir(): string {
   return process.env.KRIMTO_DATA ?? path.join(homedir(), ".krimto");