omp-conductor 0.18.0 → 0.18.1

package/src/graph-health.ts

@@ -33,6 +33,19 @@ export type CodeGraphHealth =
         indexer: CheckState;
         mcpMount: McpMountState;
       };
+      /**
+       * Session-recorded graph-tools observations over this project's runs
+       * (#726): what dispatched sessions' registries actually held at start.
+       * `recorded: 0` means no run has ever recorded the fact — "observed" is
+       * never claimed without one, which is the whole honesty contract of the
+       * state. This is the runtime counterpart to `prerequisites.mcpMount`,
+       * which is deliberately a *config* finding.
+       */
+      session: {
+        recorded: number;
+        present: number;
+        absent: number;
+      };
       repos: CodeGraphRepoHealth[];
       timer: {
         enabled: "enabled" | "disabled" | "unknown";
@@ -61,6 +74,7 @@ export function pendingCodeGraph(project: ProjectConfig, now = Date.now()): Code
     status: "unknown",
     checkedAt: new Date(now).toISOString(),
     prerequisites: { indexer: "unknown", mcpMount: "unknown" },
+    session: { recorded: 0, present: 0, absent: 0 },
     repos: repos.map((repo) => ({
       name: repo.name,
       path: repo.graphProject,
@@ -78,6 +92,12 @@ export interface CodeGraphProbeDeps {
   exists(path: string): boolean;
   run(command: string, args: readonly string[]): Promise<ReadOnlyCommandResult>;
   now(): number;
+  /**
+   * Session-recorded graph-tools observations for the probed project (#726).
+   * Absent, the probe reports no observation — which is exactly what a caller
+   * that has no store must report, and never a claim that tools were absent.
+   */
+  graphToolsObservations?(): { recorded: number; present: number; absent: number };
 }
 
 async function runReadOnly(command: string, args: readonly string[]): Promise<ReadOnlyCommandResult> {
@@ -104,7 +124,7 @@ async function runReadOnly(command: string, args: readonly string[]): Promise<Re
   }
 }
 
-const DEFAULT_DEPS: CodeGraphProbeDeps = {
+export const DEFAULT_DEPS: CodeGraphProbeDeps = {
   prereqs: resolvePrereqs,
   exists: existsSync,
   run: runReadOnly,
@@ -241,6 +261,19 @@ export async function probeCodeGraph(
   if (indexer === "missing") reasons.push("indexer is not present on PATH");
   if (mcpMount === "unconfigured") reasons.push("worker MCP configuration does not mount the indexer");
 
+  // The runtime half (#726): what dispatched sessions actually had in their
+  // registries. `recorded: 0` (no run ever recorded an observation, or no
+  // store-backed reader) contributes nothing — "observed" is only ever claimed
+  // from a run that recorded it. An observed absence is the signal this
+  // feature exists to surface: config says "mounted" while sessions ran
+  // without the tools, which is exactly the blind spot `mcp.json` alone had.
+  const session = deps.graphToolsObservations?.() ?? { recorded: 0, present: 0, absent: 0 };
+  if (session.recorded > 0 && session.absent > 0) {
+    reasons.push(
+      `graph tools observed absent from the session registry in ${session.absent} of ${session.recorded} runs`,
+    );
+  }
+
   // The units are per project (`cbm-reindex-<project>.*`): probing the shared
   // stem would report project B's health against project A's timer, and with
   // both installed the answer would be whichever the probe guessed (#720).
@@ -301,6 +334,7 @@ export async function probeCodeGraph(
     status: uncertain ? "unknown" : reasons.length === 0 ? "healthy" : "degraded",
     checkedAt,
     prerequisites: { indexer, mcpMount },
+    session,
     repos,
     timer: { enabled, active },
     refresh: refresh.health,

package/src/graph.ts

@@ -29,7 +29,7 @@ import { chmodSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "n
 import { homedir, userInfo } from "node:os";
 import { dirname, join } from "node:path";
 import { expandHome, stateDir } from "./config.ts";
-import type { ProjectConfig, RepoTarget } from "./types.ts";
+import type { GraphToolsObservation, ProjectConfig, RepoTarget } from "./types.ts";
 
 /**
  * The indexer's own CLI, invoked by name rather than by path so the generated
@@ -38,6 +38,71 @@ import type { ProjectConfig, RepoTarget } from "./types.ts";
  */
 const INDEXER = "codebase-memory-mcp";
 
+/**
+ * The MCP server name the graph tools arrive under in a session's registry,
+ * in the spellings the harness prefixes tools with (#726). `graphToolsPresent`
+ * matches against these, so the runtime observation and `resolvePrereqs`'s
+ * config check share one identity and cannot drift apart. The underscore form
+ * is the harness's normalised spelling for a server name; the verbatim form
+ * covers servers that keep their hyphens.
+ */
+export const GRAPH_MCP_SERVER_NAMES: readonly string[] = [INDEXER, INDEXER.replace(/-/g, "_")];
+
+/**
+ * Whether the code-graph tools are in a live session's registry (#726).
+ *
+ * Takes the session's own enabled tool names and matches the harness's MCP
+ * mounting convention (`mcp__<server>_<tool>`). This is the runtime
+ * observation: unlike {@link resolvePrereqs}'s `mounted` (which reads
+ * `mcp.json` and can only say what a session should mount), it answers what
+ * the session actually had, so "the model ignored a tool it had" and "the
+ * tool was missing" stop looking identical from outside the session.
+ */
+export function graphToolsPresent(toolNames: readonly string[]): boolean {
+  return toolNames.some(
+    (name) =>
+      name.startsWith("mcp__") &&
+      GRAPH_MCP_SERVER_NAMES.some((server) => name.startsWith(`mcp__${server}_`)),
+  );
+}
+
+/**
+ * Poll a session's registry for the code-graph observation (#726).
+ *
+ * Measured against the real harness rather than assumed: MCP wiring finalises
+ * after `createAgentSession` resolves (a deferred discovery pass), so the
+ * registry read can throw in the window right after session creation, and the
+ * graph tools surface under the *enabled* names — the active names stop at
+ * the core tools. This therefore polls the enabled surface until the read
+ * stops throwing, bounded by `deadlineMs`; a surface that never becomes
+ * readable (or a build that does not expose one — `getEnabledToolNames` is
+ * `undefined`) records *no* observation — never "graph tools absent", which
+ * is the `present: false` truth value of a surface that was read.
+ *
+ * @param getEnabledToolNames the session's `getEnabledToolNames` read, already
+ *   bound to its session (the SDK method dereferences private state), or
+ *   `undefined` when the harness surface is absent
+ */
+export async function observeGraphTools(
+  getEnabledToolNames: (() => string[]) | undefined,
+  options: { intervalMs?: number; deadlineMs?: number } = {},
+): Promise<GraphToolsObservation | undefined> {
+  if (getEnabledToolNames === undefined) return undefined;
+  const intervalMs = options.intervalMs ?? 250;
+  const deadlineMs = options.deadlineMs ?? 15_000;
+  const start = Date.now();
+  for (;;) {
+    try {
+      return { present: graphToolsPresent(getEnabledToolNames()), at: Date.now() };
+    } catch {
+      if (Date.now() - start >= deadlineMs) return undefined;
+      const { promise, resolve } = Promise.withResolvers<void>();
+      setTimeout(resolve, intervalMs);
+      await promise;
+    }
+  }
+}
+
 /** The shared prefix of every reindex artefact; `cbm` is the indexer's own prefix. */
 export const REINDEX_UNIT = "cbm-reindex";
 

package/src/harness-loader.ts

@@ -0,0 +1,59 @@
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+
+import {
+  OMP_HARNESS_PACKAGE,
+  OMP_NATIVES_PACKAGE,
+  packageNodeModulesRoot,
+} from "./host.ts";
+
+export interface HarnessAttestation {
+  path: string;
+  version: string;
+  nativePath: string;
+}
+
+/** Resolve the installed peer from this package's directory, never Bun's ambient cache. */
+export function resolveHarnessEntry(moduleDir: string = import.meta.dir): string {
+  return Bun.resolveSync(OMP_HARNESS_PACKAGE, moduleDir);
+}
+
+/** The installed peer version belonging to a resolved harness entry. */
+export function harnessVersion(entry: string): string | undefined {
+  const root = packageNodeModulesRoot(entry);
+  if (root === undefined) return undefined;
+  try {
+    const parsed: unknown = JSON.parse(
+      readFileSync(join(root, OMP_HARNESS_PACKAGE, "package.json"), "utf8"),
+    );
+    if (parsed === null || typeof parsed !== "object") return undefined;
+    const version = Reflect.get(parsed, "version");
+    return typeof version === "string" && version !== "" ? version : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+/**
+ * Exercise the worker's real import contract: explicitly anchored peer and
+ * native-addon resolution, with the caller responsible for passing
+ * `--no-install` so neither import can fall through to Bun's package cache.
+ */
+export async function probeHarness(moduleDir: string = import.meta.dir): Promise<HarnessAttestation> {
+  const path = resolveHarnessEntry(moduleDir);
+  await import(path);
+  const version = harnessVersion(path);
+  if (version === undefined) throw new Error(`cannot read the harness version for ${path}`);
+  const nativePath = Bun.resolveSync(OMP_NATIVES_PACKAGE, dirname(path));
+  await import(nativePath);
+  return { path, version, nativePath };
+}
+
+if (import.meta.main) {
+  try {
+    process.stdout.write(`${JSON.stringify(await probeHarness())}\n`);
+  } catch (cause) {
+    process.stderr.write(`${cause instanceof Error ? cause.stack ?? cause.message : String(cause)}\n`);
+    process.exitCode = 1;
+  }
+}