supipowers 1.5.3 → 2.0.1

package/src/commands/doctor.ts

@@ -7,6 +7,10 @@ import { detectContextMode } from "../context-mode/detector.js";
 import { isLspAvailable } from "../lsp/detector.js";
 import { summarizeEnabledGates } from "../quality/setup.js";
 import { DEPENDENCIES } from "../deps/registry.js";
+import { formatReliabilitySection, loadReliabilitySummaries } from "../storage/reliability-metrics.js";
+import { getMetricsStore, getSessionId } from "../context-mode/hooks.js";
+import { getProjectStatePath, getProjectStateDir } from "../workspace/state-paths.js";
+import { basename } from "node:path";
 
 export interface CheckResult {
   name: string;
@@ -225,22 +229,210 @@ const CTX_TOOL_NAMES: Record<string, string> = {
   ctxIndex: "ctx_index",
   ctxSearch: "ctx_search",
   ctxFetchAndIndex: "ctx_fetch_and_index",
+  ctxStats: "ctx_stats",
+  ctxPurge: "ctx_purge",
+  ctxRepomap: "ctx_repomap",
+  ctxSymbol: "ctx_symbol",
 };
 
-export function checkContextMode(_activeTools: string[]): CheckResult {
-  const status = detectContextMode();
+export function checkContextMode(activeTools: string[]): CheckResult {
+  // Reflect the same active-tool-aware view the runtime routing/prompt layers
+  // use, so the doctor cannot claim ctx_* tools are available when the model
+  // can't actually call them.
+  const status = detectContextMode(activeTools);
 
   const foundNames = Object.entries(status.tools)
-    .filter(([, v]) => v)
-    .map(([k]) => CTX_TOOL_NAMES[k] || k);
+    .filter(([, value]) => value)
+    .map(([key]) => CTX_TOOL_NAMES[key] || key);
+
+  if (!status.available) {
+    return {
+      name: "Context Mode",
+      presence: { ok: false, detail: "No ctx_* tools active in this session" },
+      functional: { ok: false, detail: "Inactive — routing rescue path will be skipped this turn" },
+    };
+  }
 
   return {
     name: "Context Mode",
-    presence: { ok: true, detail: "Native tools (built-in)" },
+    presence: { ok: true, detail: "Native tools active" },
     functional: { ok: true, detail: foundNames.join(", ") },
   };
 }
 
+export function checkLazyTools(platform: Platform, cwd: string): CheckResult {
+  const inspection = (() => {
+    try {
+      return inspectConfig(platform.paths, cwd);
+    } catch (error) {
+      return error instanceof Error ? error : new Error(String(error));
+    }
+  })();
+
+  if (inspection instanceof Error) {
+    return {
+      name: "Lazy Tools",
+      presence: { ok: false, detail: `Unable to inspect config: ${inspection.message}` },
+    };
+  }
+
+  if (!inspection.effectiveConfig) {
+    return {
+      name: "Lazy Tools",
+      presence: { ok: false, detail: "Skipped: config is invalid" },
+      functional: { ok: false, detail: formatConfigErrors(inspection) },
+    };
+  }
+
+  const config = inspection.effectiveConfig;
+
+  if (!config.contextMode.enabled) {
+    return {
+      name: "Lazy Tools",
+      presence: { ok: false, detail: "Disabled (contextMode.enabled = false)" },
+    };
+  }
+
+  if (!config.contextMode.lazyTools.enabled) {
+    return {
+      name: "Lazy Tools",
+      presence: { ok: false, detail: "Disabled (contextMode.lazyTools.enabled = false)" },
+    };
+  }
+
+  if (!platform.capabilities.activeToolFiltering) {
+    return {
+      name: "Lazy Tools",
+      presence: {
+        ok: false,
+        detail:
+          "Degraded: contextMode.lazyTools.enabled is true but active-tool filtering is unavailable; upgrade OMP/supipowers adapter or disable contextMode.lazyTools.enabled.",
+      },
+    };
+  }
+
+  return {
+    name: "Lazy Tools",
+    presence: { ok: true, detail: "L7 active-tool filtering available" },
+    functional: { ok: true, detail: `mode: ${config.contextMode.lazyTools.mode}` },
+  };
+}
+
+/** Metrics health checks for the L1 measurement layer. */
+export function checkMetrics(
+  platform: Platform,
+  cwd: string,
+  now = Date.now(),
+): { section: SectionResult; absDbPath: string } {
+  const absDbPath = getProjectStatePath(
+    platform.paths,
+    cwd,
+    "sessions",
+    "metrics.db",
+  );
+  const store = getMetricsStore();
+  const sessionId = getSessionId();
+
+  const reachable: CheckResult = store
+    ? {
+        name: "metrics-db-reachable",
+        presence: { ok: true, detail: `Metrics DB: ${absDbPath}` },
+        functional: { ok: true, detail: "Open" },
+      }
+    : (() => {
+        // Differentiate the two reasons `getMetricsStore()` returns null:
+        //   1. `contextMode.enabled = false` — the hook never registered, so the
+        //      remediation is to flip the config flag.
+        //   2. Init failed (FS perms, sqlite error, etc.) — the hook registered
+        //      but `ensureMetricsStore` returned null and logged the error.
+        // Saying "run /supi:context to bootstrap" was wrong: that command only
+        // reads the ref and never initializes the store.
+        const enabled = (() => {
+          try {
+            return inspectConfig(platform.paths, cwd).effectiveConfig?.contextMode?.enabled ?? true;
+          } catch {
+            return true;
+          }
+        })();
+        const detail = enabled
+          ? `Failed to initialize \u2014 check session_start logs (${absDbPath})`
+          : `Disabled (contextMode.enabled = false) \u2014 set it to true in config to enable metrics (${absDbPath})`;
+        return {
+          name: "metrics-db-reachable",
+          presence: { ok: false, detail },
+        };
+      })();
+
+  const writeFailures = (() => {
+    try {
+      return store?.getSessionWriteFailures(sessionId) ?? 0;
+    } catch {
+      return 0;
+    }
+  })();
+  const writeHealthy: CheckResult = store
+    ? {
+        name: "metrics-write-healthy",
+        presence: {
+          ok: writeFailures === 0,
+          detail:
+            writeFailures === 0
+              ? "No write failures this session"
+              : `${writeFailures} write_failures \u2014 see /supi:clear or filesystem health`,
+        },
+      }
+    : {
+        name: "metrics-write-healthy",
+        presence: { ok: false, detail: "Skipped \u2014 metrics store unavailable" },
+      };
+
+  const lastPruneAt = (() => {
+    try {
+      // Use the store's bound slug rather than re-deriving from cwd; the store
+      // is the source of truth for which project_meta_metrics row matters.
+      const slug = store?.projectSlug ?? basename(getProjectStateDir(platform.paths, cwd));
+      return store?.getProjectMeta(slug)?.last_prune_at ?? null;
+    } catch {
+      return null;
+    }
+  })();
+  const ONE_DAY_MS = 24 * 60 * 60 * 1000;
+  const pruneFresh: CheckResult = !store
+    ? {
+        name: "metrics-prune-fresh",
+        presence: { ok: false, detail: "Skipped \u2014 metrics store unavailable" },
+      }
+    : lastPruneAt === null
+      ? {
+          name: "metrics-prune-fresh",
+          presence: {
+            ok: false,
+            detail: "Never pruned; runs on session_shutdown",
+          },
+        }
+      : now - lastPruneAt <= ONE_DAY_MS
+        ? {
+            name: "metrics-prune-fresh",
+            presence: { ok: true, detail: "Pruned within 24h" },
+          }
+        : {
+            name: "metrics-prune-fresh",
+            presence: {
+              ok: false,
+              detail: `Stale (${Math.round((now - lastPruneAt) / ONE_DAY_MS)}d ago)`,
+            },
+          };
+
+  return {
+    section: {
+      title: `Metrics (${absDbPath})`,
+      checks: [reachable, writeHealthy, pruneFresh],
+    },
+    absDbPath,
+  };
+}
+
+
 export async function checkNpm(platform: Platform): Promise<CheckResult> {
   try {
     const vResult = await platform.exec("npm", ["--version"]);
@@ -279,6 +471,7 @@ export async function runDoctorChecks(platform: Platform, cwd: string): Promise<
     checkLsp(activeTools),
     mcpResult,
     checkContextMode(activeTools),
+    checkLazyTools(platform, cwd),
     await checkNpm(platform),
   ];
 
@@ -286,13 +479,41 @@ export async function runDoctorChecks(platform: Platform, cwd: string): Promise<
   const mcpAvailable = mcpResult.presence.ok;
   const capChecks = checkCapabilities(platform.capabilities, mcpAvailable);
 
+  const metrics = checkMetrics(platform, cwd);
+
   return [
     { title: "Core Infrastructure", checks: core },
     { title: "Integrations", checks: integrations },
     { title: "Platform Capabilities", checks: capChecks },
+    metrics.section,
   ];
 }
 
+/**
+ * Recommended OMP settings that materially improve supipowers UX.
+ *
+ * These are *suggestions*, not health checks — supipowers cannot read OMP's
+ * `settings.json` directly, so we cannot detect whether the user has the
+ * setting on. We surface them at the bottom of `/supi:doctor` as a
+ * non-failing tip block.
+ */
+export function getDoctorRecommendations(): string[] {
+  return [
+    "Set `tools.elideFileMutationInputs: true` (OMP ≥14.7.0) — elides `write`/`edit`/`apply_patch` payloads from history after success. Saves significant context on long sessions like `/supi:ultraplan execute` and `/supi:harness implement`.",
+    "Update to OMP ≥14.7.2 — fixes the `Working…` spinner staying active after read-only commands such as `/supi:status`, `/supi:doctor`, `/supi:context`, and `/supi:clear`. (oh-my-pi#927)",
+  ];
+}
+
+function formatRecommendationsSection(recommendations: string[]): string[] {
+  if (recommendations.length === 0) return [];
+  const lines: string[] = ["Recommendations"];
+  for (const tip of recommendations) {
+    lines.push(`  → ${tip}`);
+  }
+  lines.push("");
+  return lines;
+}
+
 function formatReport(sections: SectionResult[]): string {
   const lines: string[] = ["/supi:doctor", ""];
   for (const section of sections) {
@@ -302,17 +523,23 @@ function formatReport(sections: SectionResult[]): string {
     }
     lines.push("");
   }
+  lines.push(...formatRecommendationsSection(getDoctorRecommendations()));
   lines.push(formatSummary(sections));
   return lines.join("\n");
 }
 
+export function formatReliabilityReportLines(platform: Platform, cwd: string): string[] {
+  return formatReliabilitySection(loadReliabilitySummaries(platform.paths, cwd));
+}
+
 export function handleDoctor(platform: Platform, ctx: PlatformContext): void {
   if (!ctx.hasUI) return;
 
   void (async () => {
     try {
       const sections = await runDoctorChecks(platform, ctx.cwd);
-      const report = formatReport(sections);
+      const reliabilityLines = formatReliabilityReportLines(platform, ctx.cwd);
+      const report = `${formatReport(sections)}\n\n${reliabilityLines.join("\n")}`;
       ctx.ui.notify(report, "info");
     } catch (err) {
       ctx.ui.notify(`Doctor failed: ${(err as Error).message}`, "error");
@@ -333,6 +560,7 @@ const CAPABILITY_LABELS: Partial<Record<keyof PlatformCapabilities, string>> = {
   compactionHooks: "Context compression",
   customWidgets: "Progress widgets",
   registerTool: "Custom tool registration",
+  activeToolFiltering: "Active-tool filtering",
 };
 
 export function checkCapabilities(