@krimto-labs/krimto 0.2.20 → 0.2.22

package/bin/krimto.mjs

@@ -13,7 +13,9 @@ try {
   const cmd =
     rawCmd === "team" && typeof process.argv[3] === "string"
       ? `team ${process.argv[3]}`
-      : rawCmd;
+      : rawCmd === "set" && typeof process.argv[3] === "string"
+        ? `set ${process.argv[3]}`
+        : rawCmd;
 
   // Guard: `krimto team` alone (or with an unknown subverb) shouldn't fall through to the stdio
   // MCP server. Print usage and exit instead.
@@ -27,6 +29,16 @@ try {
     process.exit(2);
   }
 
+  // Same guard for `krimto set <subverb>`.
+  const knownSetCmds = ["set identity"];
+  if (rawCmd === "set" && !knownSetCmds.includes(cmd)) {
+    process.stderr.write(
+      "Usage: krimto set <identity> <value>\n" +
+        "  identity <email>   Change the identity used for new fact writes\n",
+    );
+    process.exit(2);
+  }
+
   if (cmd === "--help" || cmd === "-h" || cmd === "help") {
     // `krimto --help` — surface every subcommand so a user who didn't read the README can still
     // discover them. Version is read from the server module so it never drifts from KRIMTO_VERSION.
@@ -351,6 +363,36 @@ try {
     // doesn't have to chase the README. Honors KRIMTO_IDENTITY when set.
     const { formatConnect } = await tsImport("../src/cli/connect.ts", import.meta.url);
     process.stdout.write(formatConnect({ identity: process.env.KRIMTO_IDENTITY }));
+  } else if (cmd === "whoami") {
+    // `krimto whoami` — show the active KRIMTO_IDENTITY and every place it's currently set
+    // (each editor's MCP config + the always-running service unit). Surfaces drift between
+    // sources so users notice before notes start splitting across two scopes.
+    const { runWhoami } = await tsImport("../src/cli/whoami.ts", import.meta.url);
+    const result = await runWhoami();
+    process.stdout.write(result.message);
+    if (result.mismatch) process.exitCode = 1;
+  } else if (cmd === "set identity") {
+    // `krimto set identity <email>` — update KRIMTO_IDENTITY across every registered editor
+    // and the always-running service. Preserves other env keys (KRIMTO_EMBED_*). Existing
+    // notes do NOT move — that's an intentional separate step.
+    const newIdentity = process.argv[4];
+    const flags = process.argv.slice(5);
+    const yes = flags.includes("--yes");
+    if (!newIdentity) {
+      process.stderr.write(
+        "Usage: krimto set identity <email> [--yes]\n  e.g. krimto set identity alice@acme.com\n",
+      );
+      process.exit(2);
+    }
+    const { runSetIdentity } = await tsImport("../src/cli/setIdentity.ts", import.meta.url);
+    const { resolveDataDir } = await tsImport("../src/server/index.ts", import.meta.url);
+    const result = await runSetIdentity({
+      identity: newIdentity,
+      dataDir: resolveDataDir(),
+      yes,
+    });
+    process.stdout.write(result.message);
+    if (result.status === "error") process.exitCode = 1;
   } else {
     const mod = await tsImport("../src/server/index.ts", import.meta.url);
     await mod.main();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@krimto-labs/krimto",
-  "version": "0.2.20",
+  "version": "0.2.22",
   "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

@@ -126,10 +126,12 @@ async function askEditorsList(
       description: current.includes(env.editor)
         ? "currently connected"
         : env.present
-          ? "detected on this machine"
-          : env.mcpWire === null
-            ? "not detected — manual snippet only"
-            : "not detected — toggle on if you want anyway",
+          ? "detected in this project"
+          : env.installed
+            ? "installed on this machine (not in this project yet)"
+            : env.mcpWire === null
+              ? "not detected — manual snippet only"
+              : "not detected — toggle on if you want anyway",
       checked: current.includes(env.editor),
     })),
   });

package/src/cli/help.ts

@@ -37,6 +37,10 @@ export function formatHelp(version: string): string {
     "    rm <id>            Delete a fact (file + index + git deletion commit)",
     "    reindex            Rebuild index.db from markdown (fixes manual-delete orphans)",
     "",
+    "  Identity:",
+    "    whoami             Show which email Krimto is using (and where it's set)",
+    "    set identity <e>   Change the identity used for new fact writes",
+    "",
     "  Diagnose:",
     "    verify-connection  Is my agent actually calling Krimto? (live status + last 5 calls)",
     "    setup-remote <url> Wire data dir to a git remote, verify the push works",

package/src/cli/init.ts

@@ -106,14 +106,52 @@ export type McpWireMethod =
 
 export interface EditorEnvironment {
   editor: EditorKind;
-  /** True when local signals (file/dir presence) indicate this editor is in use here. */
+  /**
+   * True when local **project-level** signals (file/dir presence inside `cwd`) indicate this
+   * editor is in use *for this project*. Narrow scope — `.cursor/`, `CLAUDE.md`, etc.
+   */
   present: boolean;
+  /**
+   * v0.2.21: True when **machine-level** signals (files/dirs in `homeDir`) indicate this editor
+   * is installed and has been used at least once on this machine. Broader than `present` — catches
+   * the case where a user is editing in Cursor but the project folder hasn't acquired a `.cursor/`
+   * directory yet. The wizard preselects an editor when `present || installed`.
+   */
+  installed: boolean;
   /** Project-relative rules-file path (the CLAUDE.md / .cursor/rules/krimto.mdc / etc.). */
   rulesPath: string;
   /** How to wire MCP config for this editor, or `null` when wiring isn't automated yet. */
   mcpWire: McpWireMethod | null;
 }
 
+/**
+ * v0.2.21: Machine-level installation check. Returns true when this editor's home-dir footprint
+ * suggests it's been installed + run on this machine. Used by `detectEditorEnvironments` to
+ * populate `EditorEnvironment.installed` so the wizard can preselect editors even when the
+ * current project folder has no editor-specific signals yet.
+ *
+ * The home-dir paths checked are well-known per editor: each is created on first launch.
+ *   • Cursor       — `~/.cursor/`
+ *   • Claude Code  — `~/.claude.json` (user config) or `~/.claude/` (project data)
+ *   • Codex        — `~/.codex/`
+ *   • Gemini CLI   — `~/.gemini/`
+ *
+ * False positives (folder exists from a previous uninstalled tool) are harmless: the user can
+ * untoggle. False negatives (editor installed but never launched) are equally rare in practice.
+ */
+async function isInstalledOnMachine(editor: EditorKind, homeDir: string): Promise<boolean> {
+  if (editor === "cursor") return exists(path.join(homeDir, ".cursor"));
+  if (editor === "claude-code") {
+    return (
+      (await exists(path.join(homeDir, ".claude.json"))) ||
+      (await exists(path.join(homeDir, ".claude")))
+    );
+  }
+  if (editor === "codex") return exists(path.join(homeDir, ".codex"));
+  if (editor === "gemini-cli") return exists(path.join(homeDir, ".gemini"));
+  return false;
+}
+
 /**
  * Resolve every editor Krimto can reason about into an `EditorEnvironment` triple
  * (editor + rules-file path + mcp-wiring method). `present` reflects detection signals;
@@ -136,10 +174,18 @@ export async function detectEditorEnvironments(
     (await exists(path.join(cwd, ".gemini")));
   const cursorPresent = await exists(path.join(cwd, ".cursor"));
 
+  // v0.2.21: machine-level installation signals — catch the case where the user is editing in
+  // Cursor (or Claude Code) but the project folder hasn't acquired editor-specific files yet.
+  const cursorInstalled = await isInstalledOnMachine("cursor", homeDir);
+  const claudeInstalled = await isInstalledOnMachine("claude-code", homeDir);
+  const codexInstalled = await isInstalledOnMachine("codex", homeDir);
+  const geminiInstalled = await isInstalledOnMachine("gemini-cli", homeDir);
+
   return [
     {
       editor: "cursor",
       present: cursorPresent,
+      installed: cursorInstalled,
       rulesPath: path.join(".cursor", "rules", "krimto.mdc"),
       mcpWire: {
         method: "json",
@@ -150,6 +196,7 @@ export async function detectEditorEnvironments(
     {
       editor: "claude-code",
       present: claudePresent,
+      installed: claudeInstalled,
       rulesPath: "CLAUDE.md",
       // `claude mcp add krimto ...` is the supported invocation. Shelling out to the editor's
       // own CLI sidesteps the question of which exact file Claude Code persists MCP config in
@@ -163,6 +210,7 @@ export async function detectEditorEnvironments(
     {
       editor: "gemini-cli",
       present: geminiPresent,
+      installed: geminiInstalled,
       rulesPath: "GEMINI.md",
       // Deferred — Gemini CLI's MCP config path needs empirical confirmation before we write
       // to it. v0.2.17 prints a copy-paste snippet instead.
@@ -171,6 +219,7 @@ export async function detectEditorEnvironments(
     {
       editor: "codex",
       present: codexPresent,
+      installed: codexInstalled,
       rulesPath: "AGENTS.md",
       // Deferred — Codex's config is TOML (`~/.codex/config.toml`); writing TOML safely needs
       // a parser we haven't added yet. v0.2.17 prints a copy-paste snippet instead.

package/src/cli/join.ts

@@ -180,11 +180,14 @@ async function askEditors(envs: EditorEnvironment[]): Promise<EditorKind[]> {
       value: env.editor,
       name: EDITOR_LABEL[env.editor],
       description: env.present
-        ? "detected on this machine"
-        : env.mcpWire === null
-          ? "not detected — manual snippet only"
-          : "not detected — toggle on if you want anyway",
-      checked: env.present,
+        ? "detected in this project"
+        : env.installed
+          ? "installed on this machine (not in this project yet)"
+          : env.mcpWire === null
+            ? "not detected — manual snippet only"
+            : "not detected — toggle on if you want anyway",
+      // v0.2.21: preselect on either signal — installed-on-machine still counts.
+      checked: env.present || env.installed,
     })),
   });
 }

package/src/cli/setIdentity.ts

@@ -0,0 +1,232 @@
+// `krimto set identity <email>` — change KRIMTO_IDENTITY everywhere the wizard wrote it.
+//
+// Surfaces touched (in order):
+//   1. Each registered editor's MCP config — for JSON-method editors, mutate
+//      `env.KRIMTO_IDENTITY` in place (other env keys like KRIMTO_EMBED_* are preserved).
+//      For CLI-method editors (Claude Code), rebuild a fresh stdio entry via writeMcpConfig
+//      (extra env keys are lost — known limitation noted below).
+//   2. The always-running service (launchd/systemd/schtasks) — uninstall + reinstall with
+//      the new env. Same dataDir + port as before, mirroring serviceCmd.applyService.
+//
+// HTTP-transport MCP entries don't carry identity (it lives in the service env); they are
+// left untouched.
+//
+// Existing notes do NOT migrate. The folder for the old identity stays under
+// `~/.krimto/user/<old-email>/` — moving them is intentionally a separate step (would need
+// a git rename + reindex; out of scope for this command).
+
+import { confirm } from "@inquirer/prompts";
+import { promises as fs } from "node:fs";
+import * as path from "node:path";
+
+import { stdioMcpEntry, type KrimtoMcpEntry } from "../server/connect";
+import {
+  detectEditorEnvironments,
+  detectExistingSetup,
+  type EditorEnvironment,
+  type EditorKind,
+} from "./init";
+import { writeMcpConfig } from "./mcpConfig";
+import {
+  detectPlatform,
+  installService,
+  isServiceInstalled,
+  uninstallService,
+} from "./service";
+import { defaultIO, isExitPrompt, type WizardIO } from "./promptHelpers";
+import { runWhoami } from "./whoami";
+
+const EDITOR_LABEL: Record<EditorKind, string> = {
+  cursor: "Cursor",
+  "claude-code": "Claude Code",
+  codex: "Codex",
+  "gemini-cli": "Gemini CLI",
+};
+
+// Same permissive shape used by defaultIdentity() — accepts anything that looks like name@host.
+const EMAIL_REGEX = /^[^@\s]+@[^@\s]+$/;
+
+export interface SetIdentityOptions {
+  identity: string;
+  io?: WizardIO;
+  cwd?: string;
+  homeDir?: string;
+  dataDir?: string;
+  /** Skip the confirmation prompt (CI / scripted runs). */
+  yes?: boolean;
+  /** Forwarded to install/uninstallService for tests. */
+  dryRun?: boolean;
+}
+
+export interface SetIdentityResult {
+  status: "ok" | "no-change" | "error";
+  message: string;
+  updatedEditors: EditorKind[];
+  serviceUpdated: boolean;
+}
+
+export async function runSetIdentity(opts: SetIdentityOptions): Promise<SetIdentityResult> {
+  const io = opts.io ?? defaultIO;
+  const cwd = opts.cwd ?? process.cwd();
+
+  if (!EMAIL_REGEX.test(opts.identity)) {
+    return {
+      status: "error",
+      message:
+        `\n❌ Not a valid email: "${opts.identity}"\n` +
+        `   Expected something like name@example.com\n\n`,
+      updatedEditors: [],
+      serviceUpdated: false,
+    };
+  }
+
+  const current = await runWhoami({ cwd, homeDir: opts.homeDir });
+  const snapshot = await detectExistingSetup(cwd, opts.homeDir);
+
+  if (!snapshot.configured) {
+    return {
+      status: "error",
+      message: "\n❌ Krimto isn't set up here yet. Run `krimto init` first.\n\n",
+      updatedEditors: [],
+      serviceUpdated: false,
+    };
+  }
+
+  if (current.activeIdentity === opts.identity && !current.mismatch) {
+    return {
+      status: "no-change",
+      message: `\nNo change — identity is already ${opts.identity}.\n\n`,
+      updatedEditors: [],
+      serviceUpdated: false,
+    };
+  }
+
+  if (!opts.yes) {
+    io.out("\nKrimto — Set identity\n\n");
+    io.out(`  Current identity: ${current.activeIdentity}\n`);
+    io.out(`  New identity:     ${opts.identity}\n\n`);
+    io.out("  Will update:\n");
+    for (const e of snapshot.registeredEditors) {
+      io.out(`    • ${EDITOR_LABEL[e]} MCP config\n`);
+    }
+    if (snapshot.runMode === "always-running") {
+      io.out("    • Background service (launchd/systemd/schtasks)\n");
+    }
+    io.out("\n  ⚠️  Existing notes will NOT move — they stay under\n");
+    io.out(`     ~/.krimto/user/${current.activeIdentity}/\n`);
+    io.out(`     New facts will go to ~/.krimto/user/${opts.identity}/\n\n`);
+    try {
+      const ok = await confirm({ message: "Apply this change?", default: true });
+      if (!ok) {
+        return {
+          status: "no-change",
+          message: "\nAborted. No changes were made.\n\n",
+          updatedEditors: [],
+          serviceUpdated: false,
+        };
+      }
+    } catch (e) {
+      if (isExitPrompt(e)) {
+        return {
+          status: "no-change",
+          message: "\nAborted. No changes were made.\n\n",
+          updatedEditors: [],
+          serviceUpdated: false,
+        };
+      }
+      throw e;
+    }
+  }
+
+  const envs = await detectEditorEnvironments(cwd, opts.homeDir);
+  const updatedEditors: EditorKind[] = [];
+  for (const env of envs) {
+    if (!snapshot.registeredEditors.includes(env.editor)) continue;
+    const ok = await updateEditorIdentity(env, opts.identity);
+    if (ok) updatedEditors.push(env.editor);
+  }
+
+  let serviceUpdated = false;
+  const platform = detectPlatform();
+  const service = await isServiceInstalled(platform, opts.homeDir);
+  if (service.installed) {
+    const dataDir = opts.dataDir ?? path.join(opts.homeDir ?? "", ".krimto");
+    await uninstallService({ platform, homeDir: opts.homeDir, dryRun: opts.dryRun });
+    await installService(
+      {
+        binPath: process.execPath,
+        args: [process.argv[1] ?? "krimto", "serve"],
+        env: { KRIMTO_IDENTITY: opts.identity, KRIMTO_DATA: dataDir, KRIMTO_HTTP_PORT: "8080" },
+        homeDir: opts.homeDir,
+      },
+      { dryRun: opts.dryRun, platform },
+    );
+    serviceUpdated = true;
+  }
+
+  const lines: string[] = ["", `✅ Identity changed → ${opts.identity}`, ""];
+  for (const e of updatedEditors) {
+    lines.push(`   • Updated ${EDITOR_LABEL[e]} MCP config`);
+  }
+  if (serviceUpdated) lines.push("   • Restarted background service");
+  if (updatedEditors.length === 0 && !serviceUpdated) {
+    lines.push("   (Nothing to update — no editors registered + no service installed)");
+  }
+  lines.push("");
+  lines.push("Restart your editor(s) so they pick up the new identity.");
+  lines.push("");
+  lines.push(`New facts → ~/.krimto/user/${opts.identity}/`);
+  lines.push(`Old facts stay at ~/.krimto/user/${current.activeIdentity}/`);
+  lines.push("");
+
+  return {
+    status: "ok",
+    message: lines.join("\n"),
+    updatedEditors,
+    serviceUpdated,
+  };
+}
+
+/**
+ * Update KRIMTO_IDENTITY in this editor's MCP entry.
+ *  • JSON method: surgical mutation preserves any other env keys (KRIMTO_EMBED_*).
+ *  • CLI method (Claude Code): rebuild + re-add via writeMcpConfig. Extra env keys are lost.
+ *  • HTTP entry (url-based): no-op — identity lives in the service env.
+ *  • mcpWire === null: no automated wiring; skip silently.
+ */
+async function updateEditorIdentity(env: EditorEnvironment, identity: string): Promise<boolean> {
+  if (env.mcpWire === null) return false;
+  if (env.mcpWire.method === "json") {
+    return updateIdentityInJson(env.mcpWire.path, env.mcpWire.key, identity);
+  }
+  const entry: KrimtoMcpEntry = { transport: "stdio", ...stdioMcpEntry({ identity }) };
+  await writeMcpConfig(env, entry);
+  return true;
+}
+
+async function updateIdentityInJson(
+  filePath: string,
+  key: string,
+  identity: string,
+): Promise<boolean> {
+  let text: string;
+  try {
+    text = await fs.readFile(filePath, "utf8");
+  } catch {
+    return false;
+  }
+  let parsed: Record<string, unknown>;
+  try {
+    parsed = JSON.parse(text) as Record<string, unknown>;
+  } catch {
+    return false;
+  }
+  const servers = parsed[key] as Record<string, unknown> | undefined;
+  if (!servers || !("krimto" in servers)) return false;
+  const krimto = servers.krimto as { env?: Record<string, string>; url?: string };
+  if (krimto.url) return false;
+  const nextEnv = { ...(krimto.env ?? {}), KRIMTO_IDENTITY: identity };
+  (servers.krimto as { env: Record<string, string> }).env = nextEnv;
+  await fs.writeFile(filePath, JSON.stringify(parsed, null, 2) + "\n", "utf8");
+  return true;
+}

package/src/cli/status.ts

@@ -17,6 +17,7 @@ import { promisify } from "node:util";
 
 import { ActivityLog, type ActivityEntry } from "../server/activity";
 import { isProcessAlive, type LockInfo } from "../server/lock";
+import { KRIMTO_VERSION } from "../server/index";
 import {
   detectEditorEnvironments,
   detectExistingSetup,
@@ -174,12 +175,12 @@ function headerLine(
 ): string {
   if (status === "ok") {
     if (lock?.alive) {
-      return `\n✅ Krimto is working · v0.2.17\n   PID ${lock.info.pid} (${lock.info.mode}), started ${humanAgo(lock.info.started, now)}\n`;
+      return `\n✅ Krimto is working · v${KRIMTO_VERSION}\n   PID ${lock.info.pid} (${lock.info.mode}), started ${humanAgo(lock.info.started, now)}\n`;
     }
-    return `\n✅ Krimto is configured · v0.2.17\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`;
   }
   if (status === "warning") {
-    return `\n⚠️  Krimto needs attention · v0.2.17\n`;
+    return `\n⚠️  Krimto needs attention · v${KRIMTO_VERSION}\n`;
   }
   return `\n🔴 Krimto isn't set up on this machine\n   Run: $ npx @krimto-labs/krimto init\n`;
 }

package/src/cli/whoami.ts

@@ -0,0 +1,172 @@
+// `krimto whoami` — show the active KRIMTO_IDENTITY and every place it's set.
+//
+// Motivation: the v0.2.21 "data-location surprise" bug class — users end up with two scopes
+// (`user/lpdthemes@gmail.com` and `user/user@localhost`) because different surfaces saw
+// different identities and they only noticed weeks later. `whoami` makes drift visible
+// before it leads to split notes.
+
+import { promises as fs } from "node:fs";
+
+import {
+  defaultIdentity,
+  detectEditorEnvironments,
+  type EditorEnvironment,
+  type EditorKind,
+} from "./init";
+import { detectPlatform, isServiceInstalled, type ServicePlatform } from "./service";
+
+const EDITOR_LABEL: Record<EditorKind, string> = {
+  cursor: "Cursor",
+  "claude-code": "Claude Code",
+  codex: "Codex",
+  "gemini-cli": "Gemini CLI",
+};
+
+export interface WhoamiOptions {
+  cwd?: string;
+  homeDir?: string;
+}
+
+export interface IdentitySource {
+  label: string;
+  /** The literal value found; `null` when nothing readable, `"(http)"` for HTTP entries with no inline identity. */
+  identity: string | null;
+  detail?: string;
+}
+
+export interface WhoamiResult {
+  /** The identity Krimto would use for a write right now (best inference). */
+  activeIdentity: string;
+  sources: IdentitySource[];
+  /** True when registered surfaces disagree on identity. */
+  mismatch: boolean;
+  message: string;
+}
+
+export async function runWhoami(opts: WhoamiOptions = {}): Promise<WhoamiResult> {
+  const cwd = opts.cwd ?? process.cwd();
+  const homeDir = opts.homeDir;
+  const envs = await detectEditorEnvironments(cwd, homeDir);
+
+  const sources: IdentitySource[] = [];
+  const distinctIdentities = new Set<string>();
+
+  for (const env of envs) {
+    const found = await readIdentityFromEditor(env);
+    if (found === null) continue;
+    sources.push(found);
+    if (found.identity && found.identity !== "(http)") distinctIdentities.add(found.identity);
+  }
+
+  const platform = detectPlatform();
+  const service = await isServiceInstalled(platform, homeDir);
+  if (service.installed && service.unitPath) {
+    const id = await readIdentityFromServiceUnit(service.unitPath, platform);
+    if (id) {
+      sources.push({ label: "Background service", identity: id, detail: service.unitPath });
+      distinctIdentities.add(id);
+    }
+  }
+
+  const envOverride = process.env.KRIMTO_IDENTITY ?? null;
+  const gitDefault = await defaultIdentity();
+
+  // Active identity = first concrete source we found; fall back through env → git → server default.
+  const firstConcrete = sources.find((s) => s.identity && s.identity !== "(http)")?.identity;
+  const activeIdentity = firstConcrete ?? envOverride ?? gitDefault;
+  const mismatch = distinctIdentities.size > 1;
+
+  return {
+    activeIdentity,
+    sources,
+    mismatch,
+    message: formatWhoami({ activeIdentity, sources, mismatch, envOverride, gitDefault }),
+  };
+}
+
+async function readIdentityFromEditor(env: EditorEnvironment): Promise<IdentitySource | null> {
+  if (env.mcpWire === null || env.mcpWire.method !== "json") return null;
+  let text: string;
+  try {
+    text = await fs.readFile(env.mcpWire.path, "utf8");
+  } catch {
+    return null;
+  }
+  let parsed: Record<string, unknown>;
+  try {
+    parsed = JSON.parse(text) as Record<string, unknown>;
+  } catch {
+    return null;
+  }
+  const servers = parsed[env.mcpWire.key] as Record<string, unknown> | undefined;
+  if (!servers || !("krimto" in servers)) return null;
+  const krimto = servers.krimto as { env?: Record<string, string>; url?: string };
+  const label = `${EDITOR_LABEL[env.editor]} MCP config`;
+  if (krimto.env?.KRIMTO_IDENTITY) {
+    return { label, identity: krimto.env.KRIMTO_IDENTITY, detail: env.mcpWire.path };
+  }
+  if (krimto.url) {
+    return { label, identity: "(http)", detail: env.mcpWire.path };
+  }
+  return null;
+}
+
+async function readIdentityFromServiceUnit(
+  unitPath: string,
+  platform: ServicePlatform,
+): Promise<string | null> {
+  let text: string;
+  try {
+    text = await fs.readFile(unitPath, "utf8");
+  } catch {
+    return null;
+  }
+  if (platform === "darwin") {
+    // plist XML pattern written by installService — KRIMTO_IDENTITY appears as a <key>/<string> pair.
+    const m = text.match(/<key>KRIMTO_IDENTITY<\/key>\s*<string>([^<]+)<\/string>/);
+    return m && m[1] ? m[1] : null;
+  }
+  if (platform === "linux") {
+    const m = text.match(/KRIMTO_IDENTITY=([^"\s\n]+)/);
+    return m && m[1] ? m[1] : null;
+  }
+  // Windows: schtasks doesn't store env in a readable file we own. Skip.
+  return null;
+}
+
+function formatWhoami(opts: {
+  activeIdentity: string;
+  sources: IdentitySource[];
+  mismatch: boolean;
+  envOverride: string | null;
+  gitDefault: string;
+}): string {
+  const lines: string[] = ["", "Krimto — Identity", ""];
+  lines.push(`  Active identity:   ${opts.activeIdentity}`, "");
+  lines.push("  Where it's set:");
+  if (opts.sources.length === 0) {
+    lines.push("    (no editors registered, no service installed — run `krimto init` first)");
+  } else {
+    for (const s of opts.sources) {
+      const display = s.identity === "(http)" ? "(uses service identity)" : (s.identity ?? "(unset)");
+      const marker = s.identity === "(http)" || s.identity === opts.activeIdentity ? "✓" : "⚠";
+      lines.push(`    ${marker} ${s.label.padEnd(28)} ${display}`);
+    }
+  }
+  lines.push("");
+  lines.push("  Fallback chain (used when no source above sets it):");
+  lines.push(`    KRIMTO_IDENTITY env       ${opts.envOverride ?? "(unset)"}`);
+  lines.push(`    git config user.email     ${opts.gitDefault}`);
+  lines.push("    Server default            user@localhost");
+  lines.push("");
+  if (opts.mismatch) {
+    lines.push("  ⚠️  Mismatch — different sources disagree on identity.");
+    lines.push("     Run `krimto set identity <email>` to sync them.");
+  } else if (opts.sources.length > 0) {
+    lines.push("  ✅  All sources agree.");
+  }
+  lines.push("");
+  lines.push("To change it: krimto set identity <email>");
+  lines.push("");
+  return lines.join("\n");
+}

package/src/cli/wizard.ts

@@ -24,6 +24,7 @@ import {
   type WizardAnswers,
 } from "./init";
 import { runSetupEmbeddings } from "./setupEmbeddings";
+import { KRIMTO_VERSION } from "../server/index";
 
 const EDITOR_LABEL: Record<EditorKind, string> = {
   cursor: "Cursor",
@@ -149,7 +150,7 @@ async function runFreshWizard(
   io: WizardIO,
   snapshot: SetupSnapshot | null = null,
 ): Promise<ApplyResult | null> {
-  io.out("\nKrimto — Setting up your AI's memory · v0.2.17\n\n");
+  io.out(`\nKrimto — Setting up your AI's memory · v${KRIMTO_VERSION}\n\n`);
   const envs = await detectEditorEnvironments(cwd, opts.homeDir);
   printScan(envs, io);
 
@@ -193,13 +194,16 @@ async function askEditors(
       value: env.editor,
       name: EDITOR_LABEL[env.editor],
       description: env.present
-        ? "detected on this machine"
-        : env.mcpWire === null
-          ? "not detected — manual snippet only"
-          : "not detected — toggle on if you want anyway",
+        ? "detected in this project"
+        : env.installed
+          ? "installed on this machine (not in this project yet)"
+          : env.mcpWire === null
+            ? "not detected — manual snippet only"
+            : "not detected — toggle on if you want anyway",
+      // v0.2.21: preselect on either project-level (present) OR machine-level (installed) signal.
       checked: snapshot
         ? snapshot.registeredEditors.includes(env.editor)
-        : env.present,
+        : env.present || env.installed,
     })),
   });
 }
@@ -317,8 +321,14 @@ async function askSearch(
 function printScan(envs: EditorEnvironment[], io: WizardIO): void {
   io.out("  Scanning your machine ...\n\n");
   for (const env of envs) {
-    const dot = env.present ? "✓" : "–";
-    io.out(`    ${dot} ${EDITOR_LABEL[env.editor].padEnd(14)} ${env.present ? "detected" : "not found"}\n`);
+    // v0.2.21: three states — project-level, machine-level only, not found.
+    const dot = env.present ? "✓" : env.installed ? "~" : "–";
+    const note = env.present
+      ? "detected (in this project)"
+      : env.installed
+        ? "installed (machine-wide)"
+        : "not found";
+    io.out(`    ${dot} ${EDITOR_LABEL[env.editor].padEnd(14)} ${note}\n`);
   }
   io.out("\n");
 }
@@ -430,7 +440,9 @@ export async function runInitNonInteractive(
   opts: NonInteractiveOptions = {},
 ): Promise<ApplyResult> {
   const envs = await detectEditorEnvironments(cwd, opts.homeDir);
-  const detected = envs.filter((e) => e.present).map((e) => e.editor);
+  // v0.2.21: count both project-level (`present`) AND machine-level (`installed`) signals so
+  // the --yes path matches the interactive wizard's preselect logic.
+  const detected = envs.filter((e) => e.present || e.installed).map((e) => e.editor);
   const editors = opts.editors ?? (detected.length > 0 ? detected : envs.map((e) => e.editor));
   const runMode = opts.runMode ?? (editors.length >= 2 ? "always-running" : "as-needed");
   const search = opts.search ?? "keyword";

package/src/server/index.ts

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