tokentracker-cli 0.84.8 → 0.85.0

package/src/commands/sync.js

@@ -24,6 +24,7 @@ const {
   readQoderDbMessages,
   resolveKiroDbPath,
   resolveKiroJsonlPath,
+  resolveKiroBasePath,
   resolveHermesPath,
   resolveCopilotOtelPaths,
   normalizeCopilotDbPath,
@@ -45,6 +46,8 @@ const {
   gooseInstallOwnsCursor,
   zedInstallOwnsCursor,
   hermesInstallOwnsCursor,
+  kiroInstallOwnsCursor,
+  kiroCliInstallOwnsCursor,
   copilotOtelCursorHasLegacyCliUsage,
   pruneCopilotUsageClaims,
   parseCopilotIncremental,
@@ -443,7 +446,25 @@ async function cmdSync(argv, context = {}) {
     }
     let grokHookSignalConsumed = false;
 
-    const claudeProjectsDir = path.join(home, ".claude", "projects");
+    // Claude Code home — dual-install aware (#307): a Windows host may carry
+    // a native ~/.claude plus a WSL install reachable over \\wsl$. Unlike the
+    // SQLite providers, Claude UNIONS every allowed install instead of taking
+    // resolveAllWin32Paths' single pick: under the default wsl-first mode a
+    // WSL ~/.claude would otherwise silently evict the native one from
+    // collection — and from the "disk is truth" ground-truth repair below,
+    // which would then erase the native history. The file-hash and
+    // message-hash dedup layers make the union safe. Native is listed first
+    // so the cross-environment file dedup keeps the native copy as primary.
+    const claudeNativeHome = path.join(home, ".claude");
+    const wslClaudeHome = process.platform === "win32" && wsl.shouldProbeWsl(process.env)
+      ? wsl.discoverWslHome(".claude")
+      : null;
+    const claudeInstallHomes = [];
+    if (process.platform !== "win32" || wsl.shouldProbeNative(process.env)) {
+      claudeInstallHomes.push(claudeNativeHome);
+    }
+    if (wslClaudeHome) claudeInstallHomes.push(wslClaudeHome);
+    const claudeProjectsDirs = claudeInstallHomes.map((h) => path.join(h, "projects"));
     const xdgDataHome = process.env.XDG_DATA_HOME || path.join(home, ".local", "share");
     const kiloHome = process.env.KILO_HOME || path.join(xdgDataHome, "kilo");
     const mimoHome = process.env.MIMO_HOME || path.join(xdgDataHome, "mimocode");
@@ -751,7 +772,18 @@ async function cmdSync(argv, context = {}) {
     openclawResult.eventsAggregated += openclawFallback.eventsAggregated;
     openclawResult.bucketsQueued += openclawFallback.bucketsQueued;
 
-    const claudeFiles = sourceAllowed("claude") ? await listClaudeProjectFiles(claudeProjectsDir) : [];
+    let claudeFiles = [];
+    if (sourceAllowed("claude")) {
+      const seenClaudeFiles = new Set();
+      for (const dir of claudeProjectsDirs) {
+        for (const f of await listClaudeProjectFiles(dir)) {
+          if (!seenClaudeFiles.has(f)) {
+            seenClaudeFiles.add(f);
+            claudeFiles.push(f);
+          }
+        }
+      }
+    }
     if (isFullSourceScan) {
       await reincludeClaudeMemObserverFiles({ cursors, claudeFiles, queuePath, queueStatePath });
       await repairClaudeQueueFromGroundTruth({
@@ -760,6 +792,7 @@ async function cmdSync(argv, context = {}) {
         queueStatePath,
         projectQueuePath,
         projectQueueStatePath,
+        rootDirs: claudeProjectsDirs,
       });
     }
     let claudeResult = { filesProcessed: 0, eventsAggregated: 0, bucketsQueued: 0 };
@@ -1344,30 +1377,44 @@ async function cmdSync(argv, context = {}) {
       }
     }
 
-    // ── Kiro (SQLite-based, with JSONL fallback) ──
+    // ── Kiro (SQLite-based, with JSONL fallback; dual-install aware) ──
     let kiroResult = { recordsProcessed: 0, eventsAggregated: 0, bucketsQueued: 0 };
-    const kiroDbPath = resolveKiroDbPath();
-    const kiroJsonlPath = resolveKiroJsonlPath();
-    if (sourceAllowed("kiro") && (fssync.existsSync(kiroDbPath) || fssync.existsSync(kiroJsonlPath))) {
-      if (progress?.enabled) {
-        progress.start(`Parsing Kiro ${renderBar(0)} | buckets 0`);
-      }
-      try {
-        kiroResult = await parseKiroIncremental({
-          dbPath: kiroDbPath,
-          jsonlPath: kiroJsonlPath,
-          cursors,
-          queuePath,
-          onProgress: (p) => {
-            if (!progress?.enabled) return;
-            const pct = p.total > 0 ? p.index / p.total : 1;
-            progress.update(
-              `Parsing Kiro ${renderBar(pct)} ${formatNumber(p.index)}/${formatNumber(p.total)} records | buckets ${formatNumber(p.bucketsQueued)}`,
-            );
-          },
-        });
-      } catch (err) {
-        warnProviderParseFailure("Kiro", err, opts);
+    if (sourceAllowed("kiro")) {
+      const kiroNativeBase = resolveKiroBasePath(process.env);
+      const wslKiroBase = process.platform === "win32" && wsl.shouldProbeWsl(process.env)
+        ? wsl.discoverWslHome(".config/Kiro/User/globalStorage/kiro.kiroagent")
+        : null;
+      const kiroPaths = resolveInstallPaths({ nativeValue: kiroNativeBase, wslValue: wslKiroBase });
+      // resolveInstallPaths only checks the base dir (and skips the check off
+      // win32); keep the original per-install db/jsonl presence gate so empty
+      // installs never spin up a parse or seed a cursor namespace.
+      const kiroHasData = (base) => Boolean(base)
+        && (fssync.existsSync(resolveKiroDbPath(base)) || fssync.existsSync(resolveKiroJsonlPath(base)));
+      if (!kiroHasData(kiroPaths.native)) kiroPaths.native = null;
+      if (!kiroHasData(kiroPaths.wsl)) kiroPaths.wsl = null;
+      if (kiroPaths.native || kiroPaths.wsl) {
+        if (progress?.enabled) {
+          progress.start(`Parsing Kiro ${renderBar(0)} | buckets 0`);
+        }
+        try {
+          kiroResult = await multiInstallParse({
+            paths: kiroPaths,
+            parserFn: parseKiroIncremental,
+            providerName: "kiro",
+            cursors,
+            getParams: (base) => ({
+              basePath: base,
+              dbPath: resolveKiroDbPath(base),
+              jsonlPath: resolveKiroJsonlPath(base),
+            }),
+            queuePath,
+            onProgress: makeProviderProgress("Kiro"),
+            detectInstall: (base, flatState) =>
+              kiroInstallOwnsCursor(resolveKiroDbPath(base), flatState),
+          });
+        } catch (err) {
+          warnProviderParseFailure("Kiro", err, opts);
+        }
       }
     }
 
@@ -1454,28 +1501,79 @@ async function cmdSync(argv, context = {}) {
     // token counts (billing is credit-based on Bedrock); we approximate at
     // 4 chars/token from user prompt chars and assistant response chars.
     let kiroCliResult = { recordsProcessed: 0, eventsAggregated: 0, bucketsQueued: 0 };
-    const kiroCliDb = resolveKiroCliDbPath(process.env);
-    const kiroCliSessionFiles = sourceAllowed("kiro") ? resolveKiroCliSessionFiles(process.env) : [];
-    if (sourceAllowed("kiro") && (fssync.existsSync(kiroCliDb) || kiroCliSessionFiles.length > 0)) {
-      if (progress?.enabled) {
-        progress.start(`Parsing Kiro CLI ${renderBar(0)} | buckets 0`);
+    if (sourceAllowed("kiro")) {
+      const kiroCliDb = resolveKiroCliDbPath(process.env);
+      const kiroCliSessionFiles = resolveKiroCliSessionFiles(process.env);
+      const nativeCliPresent = fssync.existsSync(kiroCliDb) || kiroCliSessionFiles.length > 0;
+
+      // Explicit overrides pin a single install — never mix them with WSL
+      // auto-discovery (mirrors the Hermes TOKENTRACKER_HERMES_HOME branch).
+      const kiroCliOverride = Boolean(process.env.KIRO_CLI_DB_PATH || process.env.KIRO_HOME);
+      let wslKiroCliEnv = null;
+      let wslKiroCliMarker = null;
+      if (!kiroCliOverride && process.platform === "win32" && wsl.shouldProbeWsl(process.env)) {
+        // A WSL install owns BOTH a data dir (~/.local/share/kiro-cli) and a
+        // sessions home (~/.kiro). Derive both from whichever probe hits so
+        // the per-install env never falls back to native paths.
+        const wslKiroHomeDir = wsl.discoverWslHome(".kiro");
+        const wslCliDataDir = wsl.discoverWslHome(".local/share/kiro-cli");
+        const wslHomeRoot = wslKiroHomeDir
+          ? path.dirname(wslKiroHomeDir)
+          : (wslCliDataDir ? path.dirname(path.dirname(path.dirname(wslCliDataDir))) : null);
+        if (wslHomeRoot) {
+          const wslCliDb = path.join(wslHomeRoot, ".local", "share", "kiro-cli", "data.sqlite3");
+          wslKiroCliEnv = {
+            ...process.env,
+            KIRO_CLI_DB_PATH: wslCliDb,
+            KIRO_HOME: path.join(wslHomeRoot, ".kiro"),
+          };
+          const wslCliPresent = fssync.existsSync(wslCliDb)
+            || resolveKiroCliSessionFiles(wslKiroCliEnv).length > 0;
+          if (wslCliPresent) wslKiroCliMarker = wslCliDb;
+        }
       }
-      try {
-        kiroCliResult = await parseKiroCliIncremental({
-          cursors,
-          queuePath,
+
+      // Paths here are install markers only — the parser resolves its DB and
+      // session files from the per-install env (KIRO_CLI_DB_PATH/KIRO_HOME).
+      const kiroCliPaths = process.platform === "win32"
+        ? wsl.resolveAllWin32Paths({
+          nativeValue: nativeCliPresent ? kiroCliDb : null,
+          wslValue: wslKiroCliMarker,
           env: process.env,
-          onProgress: (p) => {
-            if (!progress?.enabled) return;
-            const pct = p.total > 0 ? p.index / p.total : 1;
-            progress.update(
-              `Parsing Kiro CLI ${renderBar(pct)} ${formatNumber(p.index)}/${formatNumber(p.total)} sessions | buckets ${formatNumber(p.bucketsQueued)}`,
-            );
-          },
-        });
-      } catch (err) {
-        if (!opts.auto) {
-          process.stderr.write(`Kiro CLI sync: ${err.message}\n`);
+          platform: "win32",
+        })
+        : { native: nativeCliPresent ? kiroCliDb : null, wsl: null };
+      const kiroCliEnvFor = (p) =>
+        wslKiroCliEnv && p === wslKiroCliMarker ? wslKiroCliEnv : process.env;
+      if (kiroCliPaths.native || kiroCliPaths.wsl) {
+        if (progress?.enabled) {
+          progress.start(`Parsing Kiro CLI ${renderBar(0)} | buckets 0`);
+        }
+        try {
+          kiroCliResult = await multiInstallParse({
+            paths: kiroCliPaths,
+            parserFn: parseKiroCliIncremental,
+            providerName: "kiroCli",
+            cursors,
+            // Per-install env MUST come from getParams: multiInstallParse
+            // spreads shared params over it, so a top-level env would clobber
+            // the per-install one.
+            getParams: (p) => ({ env: kiroCliEnvFor(p) }),
+            queuePath,
+            onProgress: (p) => {
+              if (!progress?.enabled) return;
+              const pct = p.total > 0 ? p.index / p.total : 1;
+              progress.update(
+                `Parsing Kiro CLI ${renderBar(pct)} ${formatNumber(p.index)}/${formatNumber(p.total)} sessions | buckets ${formatNumber(p.bucketsQueued)}`,
+              );
+            },
+            detectInstall: (p, flatState) =>
+              kiroCliInstallOwnsCursor(kiroCliEnvFor(p).KIRO_CLI_DB_PATH || kiroCliDb, flatState),
+          });
+        } catch (err) {
+          if (!opts.auto) {
+            process.stderr.write(`Kiro CLI sync: ${err.message}\n`);
+          }
         }
       }
     }
@@ -4688,6 +4786,7 @@ async function repairClaudeQueueFromGroundTruth({
   queueStatePath = null,
   projectQueuePath = null,
   projectQueueStatePath = null,
+  rootDirs = null,
 }) {
   if (!cursors || typeof cursors !== "object") return false;
   const migrations = (cursors.migrations ||= {});
@@ -4695,7 +4794,13 @@ async function repairClaudeQueueFromGroundTruth({
 
   let result;
   try {
-    result = await computeClaudeGroundTruthBuckets();
+    // rootDirs must cover every install the incremental parser scans (native
+    // AND WSL): this repair's semantics are "disk is truth" — it clears all
+    // claude buckets and replaces claudeHashes wholesale, so scanning fewer
+    // roots than sync would silently drop the missing install's history.
+    result = await computeClaudeGroundTruthBuckets(
+      Array.isArray(rootDirs) && rootDirs.length > 0 ? { rootDirs } : {},
+    );
   } catch (e) {
     console.error("[sync] claude ground-truth repair: scan failed:", e?.message || e);
     return false;

package/src/lib/claude-categorizer.js

@@ -1189,9 +1189,24 @@ function toUtcHalfHourStart(ts) {
   ).toISOString();
 }
 
-async function computeClaudeGroundTruthBuckets({ rootDir = null } = {}) {
-  const root = rootDir || defaultClaudeProjectsDir();
-  const files = listSessionFiles(root);
+async function computeClaudeGroundTruthBuckets({ rootDir = null, rootDirs = null } = {}) {
+  // Multi-root (#307): a Windows host may scan a native ~/.claude/projects
+  // plus a WSL install over \\wsl$. `rootDirs` wins over the legacy single
+  // `rootDir`; duplicated session files synced between environments collapse
+  // via the msgId+reqId dedup below.
+  const roots = Array.isArray(rootDirs) && rootDirs.length > 0
+    ? rootDirs
+    : [rootDir || defaultClaudeProjectsDir()];
+  const files = [];
+  const seenFiles = new Set();
+  for (const root of roots) {
+    for (const fp of listSessionFiles(root)) {
+      if (!seenFiles.has(fp)) {
+        seenFiles.add(fp);
+        files.push(fp);
+      }
+    }
+  }
   const buckets = new Map(); // `${model}|${hourStart}` → totals
   const seenHashes = new Set();
   const userMessageBuckets = new Map(); // for conversation_count tracking
@@ -1204,7 +1219,9 @@ async function computeClaudeGroundTruthBuckets({ rootDir = null } = {}) {
       continue;
     }
     const rl = readline.createInterface({ input: stream, crlfDelay: Infinity });
-    const isMainSession = !fp.includes("/subagents/");
+    // Separator-agnostic: WSL roots are UNC paths where path.join produces
+    // backslashes (mirrors the same check in rollout.js parseClaudeFile).
+    const isMainSession = !/[\\/]subagents[\\/]/.test(fp);
 
     for await (const line of rl) {
       if (!line) continue;
@@ -1224,11 +1241,21 @@ async function computeClaudeGroundTruthBuckets({ rootDir = null } = {}) {
             typeof content === "string" ||
             (Array.isArray(content) && content.some((b) => b?.type === "text"));
           if (hasText) {
-            const ts = typeof userObj?.timestamp === "string" ? userObj.timestamp : null;
-            const hourStart = ts ? toUtcHalfHourStart(ts) : null;
-            if (hourStart) {
-              const k = `unknown|${hourStart}`;
-              userMessageBuckets.set(k, (userMessageBuckets.get(k) || 0) + 1);
+            // Dedup by line uuid (mirrors parseClaudeFile): with multiple
+            // roots the same session file exists under both the native and
+            // the \\wsl$ path, and without this every user message — and so
+            // conversation_count — would double. Usage rows are already
+            // guarded by claudeMessageDedupKey below.
+            const userKey =
+              typeof userObj?.uuid === "string" && userObj.uuid ? `u:${userObj.uuid}` : null;
+            if (!userKey || !seenHashes.has(userKey)) {
+              if (userKey) seenHashes.add(userKey);
+              const ts = typeof userObj?.timestamp === "string" ? userObj.timestamp : null;
+              const hourStart = ts ? toUtcHalfHourStart(ts) : null;
+              if (hourStart) {
+                const k = `unknown|${hourStart}`;
+                userMessageBuckets.set(k, (userMessageBuckets.get(k) || 0) + 1);
+              }
             }
           }
         }

package/src/lib/diagnostics.js

@@ -18,12 +18,43 @@ const { probeOpenclawHookState } = require("./openclaw-hook");
 const { probeOpenclawSessionPluginState } = require("./openclaw-session-plugin");
 const { probeGrokHookState } = require("./grok-hook");
 const { resolveTrackerPaths } = require("./tracker-paths");
-// TASK-011: Kiro CLI DB path inlined here to avoid pulling the ~4000-line
+const wsl = require("./wsl-probe");
+// TASK-011: Kiro paths inlined here to avoid pulling the ~4000-line
 // rollout module on every `tokentracker status` / `diagnostics` call.
-// rollout.js still exports resolveKiroCliDbPath for external callers.
+// rollout.js still exports resolveKiroCliDbPath / resolveKiroBasePath for
+// external callers; keep the platform branches in lockstep.
+function resolveKiroIdeBaseInline(env, home) {
+  const suffix = ["Kiro", "User", "globalStorage", "kiro.kiroagent"];
+  if (process.platform === "win32") {
+    const appData = typeof env.APPDATA === "string" && env.APPDATA.trim().length > 0
+      ? env.APPDATA.trim()
+      : path.join(home, "AppData", "Roaming");
+    return path.join(appData, ...suffix);
+  }
+  if (process.platform === "linux") {
+    const configHome = typeof env.XDG_CONFIG_HOME === "string" && env.XDG_CONFIG_HOME.trim().length > 0
+      ? env.XDG_CONFIG_HOME.trim()
+      : path.join(home, ".config");
+    return path.join(configHome, ...suffix);
+  }
+  return path.join(home, "Library", "Application Support", ...suffix);
+}
+
 function resolveKiroCliDbPathInline(env, home) {
   if (env.KIRO_CLI_DB_PATH) return env.KIRO_CLI_DB_PATH;
   const effectiveHome = env.HOME || home;
+  if (process.platform === "win32") {
+    const localAppData = typeof env.LOCALAPPDATA === "string" && env.LOCALAPPDATA.trim().length > 0
+      ? env.LOCALAPPDATA.trim()
+      : path.join(effectiveHome, "AppData", "Local");
+    return path.join(localAppData, "kiro-cli", "data.sqlite3");
+  }
+  if (process.platform === "linux") {
+    const dataHome = typeof env.XDG_DATA_HOME === "string" && env.XDG_DATA_HOME.trim().length > 0
+      ? env.XDG_DATA_HOME.trim()
+      : path.join(effectiveHome, ".local", "share");
+    return path.join(dataHome, "kiro-cli", "data.sqlite3");
+  }
   return path.join(
     effectiveHome,
     "Library",
@@ -106,22 +137,42 @@ async function collectTrackerDiagnostics({
   // Kiro IDE and Kiro CLI sub-path presence — merged under one "kiro" source
   // at token/cost aggregation level; operators need visibility of both
   // sub-paths here for debugging.
-  const kiroIdeDevDataDir = path.join(
-    home,
-    "Library",
-    "Application Support",
-    "Kiro",
-    "User",
-    "globalStorage",
-    "kiro.kiroagent",
-    "dev_data",
-  );
+  const kiroIdeDevDataDir = path.join(resolveKiroIdeBaseInline(process.env, home), "dev_data");
   const kiroIdePresent =
     (await safeStatSize(path.join(kiroIdeDevDataDir, "devdata.sqlite"))) > 0 ||
     (await safeStatSize(path.join(kiroIdeDevDataDir, "tokens_generated.jsonl"))) > 0;
   const kiroCliDbPath = resolveKiroCliDbPathInline(process.env, home);
   const kiroCliPresent = require("node:fs").existsSync(kiroCliDbPath);
 
+  // WSL installs (win32 only) — surfaced so `tracker doctor --json` can
+  // confirm dual-install discovery without running a sync.
+  let kiroWslInstalls = null;
+  let claudeWslProjects = null;
+  if (process.platform === "win32" && wsl.shouldProbeWsl(process.env)) {
+    const wslClaudeHome = wsl.discoverWslHome(".claude");
+    if (wslClaudeHome) claudeWslProjects = redactWslUser(path.join(wslClaudeHome, "projects"));
+    const wslIdeBase = wsl.discoverWslHome(".config/Kiro/User/globalStorage/kiro.kiroagent");
+    const wslKiroHomeDir = wsl.discoverWslHome(".kiro");
+    const wslCliDataDir = wsl.discoverWslHome(".local/share/kiro-cli");
+    const wslHomeRoot = wslKiroHomeDir
+      ? path.dirname(wslKiroHomeDir)
+      : (wslCliDataDir ? path.dirname(path.dirname(path.dirname(wslCliDataDir))) : null);
+    const wslCliDb = wslHomeRoot
+      ? path.join(wslHomeRoot, ".local", "share", "kiro-cli", "data.sqlite3")
+      : null;
+    if (wslIdeBase || wslHomeRoot) {
+      kiroWslInstalls = {
+        ide_dev_data: wslIdeBase ? redactWslUser(path.join(wslIdeBase, "dev_data")) : null,
+        ide_present: Boolean(wslIdeBase) && (
+          (await safeStatSize(path.join(wslIdeBase, "dev_data", "devdata.sqlite"))) > 0 ||
+          (await safeStatSize(path.join(wslIdeBase, "dev_data", "tokens_generated.jsonl"))) > 0
+        ),
+        cli_db: wslCliDb ? redactWslUser(wslCliDb) : null,
+        cli_present: Boolean(wslCliDb) && require("node:fs").existsSync(wslCliDb),
+      };
+    }
+  }
+
   const lastSuccessAt = uploadThrottle.lastSuccessMs
     ? new Date(uploadThrottle.lastSuccessMs).toISOString()
     : null;
@@ -143,6 +194,8 @@ async function collectTrackerDiagnostics({
       code_home: redactValue(codeHome, home),
       code_config: redactValue(codeConfigPath, home),
       claude_config: redactValue(claudeConfigPath, home),
+      claude_projects: redactValue(path.join(home, ".claude", "projects"), home),
+      ...(process.platform === "win32" ? { claude_projects_wsl: claudeWslProjects } : {}),
       gemini_config: redactValue(geminiSettingsPath, home),
       opencode_config: redactValue(opencodeConfigDir, home),
       grok_home: redactValue(grokHome, home),
@@ -154,6 +207,9 @@ async function collectTrackerDiagnostics({
     kiro: {
       ide_present: kiroIdePresent,
       cli_present: kiroCliPresent,
+      ...(process.platform === "win32"
+        ? { wsl_mode: wsl.getWslMode(process.env), wsl_installs: kiroWslInstalls }
+        : {}),
       cli_approximation:
         "Kiro CLI does not persist explicit token counts (billing is credit-based on Bedrock). Tokens are approximated at 4 chars/token from user prompt chars and assistant response chars. Source rows that came through this path have model='kiro-cli-agent' when the underlying model is unknown (auto-routing); known Bedrock ARNs canonicalize to their short name (e.g. claude-sonnet-4).",
       merge_policy:
@@ -243,6 +299,17 @@ function redactValue(value, home) {
   return value.startsWith(homeNorm) ? `~${value.slice(homeNorm.length)}` : value;
 }
 
+// UNC WSL paths embed the distro name AND the Linux username; doctor reports
+// are shared for support, so mask the user segment the same way redactValue
+// masks $HOME (\\wsl$\Ubuntu\home\alice\... → \\wsl$\Ubuntu\home\~\...).
+function redactWslUser(value) {
+  if (typeof value !== "string") return value;
+  return value.replace(
+    /^([\\/]{2}wsl(?:\$|\.localhost)[\\/][^\\/]+[\\/]home[\\/])[^\\/]+/i,
+    "$1~",
+  );
+}
+
 function redactError(message, home) {
   if (typeof message !== "string") return message;
   if (typeof home !== "string" || home.length === 0) return message;
@@ -275,4 +342,10 @@ function parseEpochMsToIso(v) {
   return d.toISOString();
 }
 
-module.exports = { collectTrackerDiagnostics };
+module.exports = {
+  collectTrackerDiagnostics,
+  // Exported for the parity test that pins these inline copies to the
+  // canonical resolvers in rollout.js (see the lockstep note above).
+  resolveKiroIdeBaseInline,
+  resolveKiroCliDbPathInline,
+};

package/src/lib/doctor.js

@@ -320,6 +320,23 @@ function buildDiagnosticsChecks(diagnostics) {
     meta: { last_error: uploadError ? uploadError.message || null : null },
   });
 
+  // Dual-install visibility (#306): surface resolved Kiro installs in the
+  // human-readable doctor output, not just the embedded diagnostics JSON.
+  const kiro = diagnostics?.kiro;
+  if (kiro && typeof kiro.wsl_mode === "string") {
+    const fmt = (present) => (present ? "yes" : "no");
+    const wslPart = kiro.wsl_installs
+      ? `wsl ide=${fmt(kiro.wsl_installs.ide_present)} cli=${fmt(kiro.wsl_installs.cli_present)}`
+      : "wsl not detected";
+    checks.push({
+      id: "kiro.installs",
+      status: "ok",
+      detail: `native ide=${fmt(kiro.ide_present)} cli=${fmt(kiro.cli_present)}; ${wslPart} (mode ${kiro.wsl_mode})`,
+      critical: false,
+      meta: { wsl_mode: kiro.wsl_mode, wsl_installs: kiro.wsl_installs || null },
+    });
+  }
+
   return checks;
 }