@krimto-labs/krimto 0.2.21 → 0.2.26

package/src/cli/service.ts

@@ -120,6 +120,70 @@ export async function isServiceInstalled(
   }
 }
 
+/**
+ * v0.2.26 — richer probe than {@link isServiceInstalled}. Distinguishes three states the
+ * smoke-6 transcript proved we needed:
+ *   • `unitPresent: true, loaded: false`    — plist on disk but not bootstrapped (failed install left over)
+ *   • `unitPresent: true, loaded: true`     — fully active service
+ *   • `unitPresent: false, loaded: false`   — clean machine (or service was uninstalled)
+ *
+ * Also returns the PID launchd is currently running, so the caller can correlate it against
+ * the lock file — when the running Krimto PID equals launchd's `pid`, the process IS the
+ * service-launched one, even if its lock file is missing the `launchedBy` field (because the
+ * process started under an old version).
+ */
+export async function probeServiceState(
+  platform: ServicePlatform = detectPlatform(),
+  homeDir: string = os.homedir(),
+): Promise<{
+  platform: ServicePlatform;
+  unitPresent: boolean;
+  loaded: boolean;
+  runningPid: number | null;
+}> {
+  const base = await isServiceInstalled(platform, homeDir);
+  const unitPresent = base.installed;
+
+  if (platform === "darwin") {
+    const uid = process.getuid?.() ?? 501;
+    try {
+      const { stdout } = await exec("launchctl", ["print", `gui/${uid}/${SERVICE_LABEL}`]);
+      const pidMatch = stdout.match(/\bpid\s*=\s*(\d+)/);
+      const pid = pidMatch && pidMatch[1] ? Number.parseInt(pidMatch[1], 10) : null;
+      return { platform, unitPresent, loaded: true, runningPid: pid };
+    } catch {
+      return { platform, unitPresent, loaded: false, runningPid: null };
+    }
+  }
+  if (platform === "linux") {
+    try {
+      // `systemctl --user is-active <name>` exits 0 with "active" when running.
+      const { stdout } = await exec("systemctl", ["--user", "is-active", SERVICE_NAME]);
+      const active = stdout.trim() === "active";
+      if (!active) return { platform, unitPresent, loaded: false, runningPid: null };
+      // Best-effort PID lookup.
+      try {
+        const { stdout: pidOut } = await exec("systemctl", ["--user", "show", "--property=MainPID", "--value", SERVICE_NAME]);
+        const pid = Number.parseInt(pidOut.trim(), 10);
+        return { platform, unitPresent, loaded: true, runningPid: Number.isFinite(pid) && pid > 0 ? pid : null };
+      } catch {
+        return { platform, unitPresent, loaded: true, runningPid: null };
+      }
+    } catch {
+      return { platform, unitPresent, loaded: false, runningPid: null };
+    }
+  }
+  if (platform === "win32") {
+    try {
+      await exec("schtasks", ["/Query", "/TN", SERVICE_NAME]);
+      return { platform, unitPresent: true, loaded: true, runningPid: null };
+    } catch {
+      return { platform, unitPresent: false, loaded: false, runningPid: null };
+    }
+  }
+  return { platform, unitPresent: false, loaded: false, runningPid: null };
+}
+
 /**
  * Install the service for the current platform. Writes the unit file (where applicable) and
  * activates the service via the platform's CLI. Pass `opts.dryRun=true` to skip activation
@@ -132,9 +196,17 @@ export async function installService(
   const platform = opts.platform ?? detectPlatform();
   const homeDir = config.homeDir ?? os.homedir();
 
-  if (platform === "darwin") return installLaunchd(config, homeDir, opts);
-  if (platform === "linux") return installSystemd(config, homeDir, opts);
-  if (platform === "win32") return installSchtasks(config, opts);
+  // v0.2.25 — Gap 8 provenance. Every service-launched Krimto stamps `launchedBy: "service"`
+  // into its lock file. We inject the marker env var here (vs every caller remembering to)
+  // so the wizard, the `service` shortcut, and any future installer share the same shape.
+  const configWithMarker: ServiceConfig = {
+    ...config,
+    env: { KRIMTO_LAUNCHED_BY: "service", ...(config.env ?? {}) },
+  };
+
+  if (platform === "darwin") return installLaunchd(configWithMarker, homeDir, opts);
+  if (platform === "linux") return installSystemd(configWithMarker, homeDir, opts);
+  if (platform === "win32") return installSchtasks(configWithMarker, opts);
 
   throw new Error(
     `Krimto's "Always running" mode isn't supported on platform "${process.platform}" yet. ` +
@@ -212,6 +284,31 @@ async function installLaunchd(
   if (opts.dryRun) {
     return { platform: "darwin", unitPath, unitContents, activateCommand, activated: false };
   }
+  // v0.2.26 — supersedes the v0.2.23 bootout+bootstrap pattern. The previous fix raced
+  // against launchd's still-tearing-down state: `launchctl bootout` returns when the unload
+  // is QUEUED, not when it completes, so the subsequent `bootstrap` could still hit EIO.
+  // Correct pattern:
+  //   • If the service is currently loaded → `launchctl kickstart -k gui/<uid>/<label>`
+  //     atomically kills + restarts the running process. Because we already overwrote the
+  //     plist above, the new process starts with the latest env / argv.
+  //   • If the service is NOT loaded → plain `bootstrap`. No race possible.
+  // `launchctl print` returning exit-0 is the canonical "is it loaded" probe.
+  const printRes = await exec("launchctl", ["print", `gui/${uid}/${SERVICE_LABEL}`]).then(
+    () => ({ loaded: true }),
+    () => ({ loaded: false }),
+  );
+  if (printRes.loaded) {
+    // Kickstart -k: send SIGTERM, wait for clean exit, then restart from the plist on disk.
+    // launchctl returns from kickstart only AFTER the new process is up, so no follow-on race.
+    await exec("launchctl", ["kickstart", "-k", `gui/${uid}/${SERVICE_LABEL}`]);
+    return {
+      platform: "darwin",
+      unitPath,
+      unitContents,
+      activateCommand: { command: "launchctl", args: ["kickstart", "-k", `gui/${uid}/${SERVICE_LABEL}`] },
+      activated: true,
+    };
+  }
   await exec(activateCommand.command, activateCommand.args);
   return { platform: "darwin", unitPath, unitContents, activateCommand, activated: true };
 }

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

@@ -16,14 +16,14 @@ import * as path from "node:path";
 import { promisify } from "node:util";
 
 import { ActivityLog, type ActivityEntry } from "../server/activity";
-import { isProcessAlive, type LockInfo } from "../server/lock";
+import { type LockInfo } from "../server/lock";
 import { KRIMTO_VERSION } from "../server/index";
 import {
   detectEditorEnvironments,
-  detectExistingSetup,
   type EditorKind,
   type SetupSnapshot,
 } from "./init";
+import { inspectRuntime } from "./inspectRuntime";
 
 const exec = promisify(execFile);
 
@@ -66,9 +66,13 @@ export async function runStatus(
   const homeDir = opts.homeDir ?? os.homedir();
   const now = opts.now ?? new Date();
 
-  const snapshot = await detectExistingSetup(cwd, homeDir);
-  const envs = await detectEditorEnvironments(cwd, homeDir);
-  const lock = await readLock(dataDir);
+  // v0.2.26 — single source of truth. status used to read 4 sources separately and the
+  // results disagreed (smoke-6 transcript). Now everything flows through inspectRuntime,
+  // which reconciles lock + launchctl + editor configs into one consistent view.
+  const runtime = await inspectRuntime(dataDir, { cwd, homeDir });
+  const snapshot = runtime.snapshot;
+  const envs = runtime.editors;
+  const lock = runtime.lock ? { info: { pid: runtime.lock.pid, started: runtime.lock.started, mode: runtime.lock.mode, launchedBy: runtime.lock.launchedBy }, alive: runtime.lock.alive } : null;
   const log = new ActivityLog(dataDir);
   const recent = await log.tail(5);
   const stats = await log.stats(5 * 60 * 1000, now);
@@ -76,7 +80,7 @@ export async function runStatus(
   const gitInfo = await readGitInfo(dataDir);
 
   const overall = pickOverall(snapshot, lock, stats);
-  const header = headerLine(overall, lock, now);
+  const header = headerLine(overall, lock, runtime.effectiveLaunchedBy, now);
 
   const connectionsBlock = renderConnections(envs, snapshot, recent);
   const storageBlock = renderStorage(dataDir, gitInfo, indexStats);
@@ -99,24 +103,6 @@ export async function runStatus(
 
 // === Helpers ===============================================================
 
-async function readLock(dataDir: string): Promise<{ info: LockInfo; alive: boolean } | null> {
-  try {
-    const raw = await fs.readFile(path.join(dataDir, ".krimto", "lock.json"), "utf8");
-    const parsed = JSON.parse(raw) as Partial<LockInfo>;
-    if (
-      typeof parsed.pid === "number" &&
-      typeof parsed.started === "string" &&
-      (parsed.mode === "stdio" || parsed.mode === "http")
-    ) {
-      const info: LockInfo = { pid: parsed.pid, started: parsed.started, mode: parsed.mode };
-      return { info, alive: isProcessAlive(info.pid) };
-    }
-  } catch {
-    /* no lock file */
-  }
-  return null;
-}
-
 async function readIndexStats(dataDir: string): Promise<{ exists: boolean; modified?: Date }> {
   try {
     const s = await fs.stat(path.join(dataDir, "index.db"));
@@ -171,11 +157,12 @@ function pickOverall(
 function headerLine(
   status: "ok" | "warning" | "error",
   lock: { info: LockInfo; alive: boolean } | null,
+  effectiveLaunchedBy: import("./inspectRuntime").RuntimeState["effectiveLaunchedBy"],
   now: Date,
 ): string {
   if (status === "ok") {
     if (lock?.alive) {
-      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 working · v${KRIMTO_VERSION}\n   PID ${lock.info.pid} (${lock.info.mode}, ${effectiveLaunchedBy ?? lock.info.launchedBy}), started ${humanAgo(lock.info.started, now)}\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`;
   }

package/src/cli/usage.ts

@@ -13,6 +13,7 @@ const EXPECTED: readonly string[] = [
   "krimto_read",
   "krimto_supersede",
   "krimto_list_scopes",
+  "krimto_whoami",
 ];
 if (MCP_TOOL_NAMES.length !== EXPECTED.length || MCP_TOOL_NAMES.some((t, i) => t !== EXPECTED[i])) {
   throw new Error("src/cli/usage.ts examples are out of sync with src/server/connect.ts MCP_TOOL_NAMES");
@@ -24,13 +25,14 @@ export function formatUsage(version: string): string {
     "",
     `✅ How to use Krimto (v${version})`,
     "",
-    "━━ The 5 tools ━━",
+    "━━ The 6 tools ━━",
     "",
     "  krimto_write        Save a fact",
     "  krimto_recall       Search facts",
     "  krimto_read         Open one fact by id",
     "  krimto_supersede    Replace a fact with a new version (old kept in git)",
     "  krimto_list_scopes  See which scopes you can read",
+    "  krimto_whoami       Ask Krimto which identity you're writing as (and your scopes)",
     "",
     "━━ DEFAULT MODE — explicit (\"use krimto to ...\") ━━",
     "",

package/src/cli/verifyConnection.ts

@@ -8,6 +8,7 @@ import { promises as fs } from "node:fs";
 import * as path from "node:path";
 
 import { ActivityLog, type ActivityEntry } from "../server/activity";
+import { inspectRuntime } from "./inspectRuntime";
 import { isProcessAlive, type LockInfo } from "../server/lock";
 
 export interface VerifyConnectionResult {
@@ -39,7 +40,12 @@ export async function runVerifyConnection(dataDir: string, now: Date = new Date(
     const raw = await fs.readFile(lockPath, "utf8");
     const parsed = JSON.parse(raw) as Partial<LockInfo>;
     if (typeof parsed.pid === "number" && typeof parsed.started === "string" && (parsed.mode === "stdio" || parsed.mode === "http")) {
-      lock = { pid: parsed.pid, started: parsed.started, mode: parsed.mode };
+      lock = {
+        pid: parsed.pid,
+        started: parsed.started,
+        mode: parsed.mode,
+        launchedBy: parsed.launchedBy === "service" ? "service" : "ad-hoc",
+      };
     } else {
       lockMalformed = true;
     }
@@ -56,12 +62,22 @@ export async function runVerifyConnection(dataDir: string, now: Date = new Date(
   let header: string;
   if (lock && isProcessAlive(lock.pid)) {
     status = "running";
+    // v0.2.26 — reconcile the lock's self-reported launchedBy against launchctl's actual
+    // state. Without this, a pre-v0.2.25 service-launched process reports "ad-hoc" because
+    // its lock file was written before the field existed.
+    const runtime = await inspectRuntime(dataDir);
+    const effective = runtime.effectiveLaunchedBy ?? lock.launchedBy;
+    const launchedByLabel =
+      effective === "service"
+        ? "service (launchd/systemd/schtasks — survives reboot)"
+        : "ad-hoc (started by `krimto serve` or an editor's stdio launcher)";
     header =
       `\n🟢 Krimto running\n` +
-      `   PID:     ${lock.pid}\n` +
-      `   Mode:    ${lock.mode}\n` +
-      `   Started: ${humanAgo(lock.started, now)}\n` +
-      `   Data:    ${dataDir}\n`;
+      `   PID:        ${lock.pid}\n` +
+      `   Mode:       ${lock.mode}\n` +
+      `   Started:    ${humanAgo(lock.started, now)}\n` +
+      `   Launched by: ${launchedByLabel}\n` +
+      `   Data:       ${dataDir}\n`;
   } else if (lock) {
     status = "stale";
     header =

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");
+}