omp-conductor 0.18.0 → 0.18.2

package/src/omp.ts

@@ -8,17 +8,16 @@
  * `createAgentSession`, `subscribe` or `abort`, exactly one file breaks.
  */
 
-/**
- * Harness package name. Held in a variable and cast to `string` at the call
- * site on purpose: a non-literal specifier stops `tsc` from trying to resolve
- * the module, which is the whole reason this shim exists.
- */
-import { chmodSync, chownSync, mkdirSync, mkdtempSync, rmSync } from "node:fs";
+import { chmodSync, mkdirSync, mkdtempSync, readFileSync, rmSync } from "node:fs";
 import { createServer, type Server, type Socket } from "node:net";
 import { tmpdir } from "node:os";
 import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
 
+import { OMP_HARNESS_PACKAGE, packageNodeModulesRoot } from "./host.ts";
+import { harnessVersion, resolveHarnessEntry } from "./harness-loader.ts";
 import { readOnlySession, worktreeConfinement } from "./confinement.ts";
+import { observeGraphTools } from "./graph.ts";
 import { releasePolicyTripwire, type GateShape, type ReleaseBlockContext } from "./release-policy.ts";
 import type {
   HostToParent,
@@ -26,11 +25,53 @@ import type {
   SessionHostSpec,
 } from "./session-host.ts";
 import { decodeFrames, encodeFrame } from "./session-host.ts";
-import type { ResolvedGrants, SessionRole } from "./types.ts";
+import type { GraphToolsObservation, ResolvedGrants, SessionRole } from "./types.ts";
 import { SESSION_ROLE_ENV } from "./types.ts";
 import { conductorVerbs } from "./verbs/client.ts";
 
-const OMP_PACKAGE = "@oh-my-pi/pi-coding-agent";
+/**
+ * Harness package name. Held in a variable and cast to `string` at the call
+ * site on purpose: a non-literal specifier stops `tsc` from trying to resolve
+ * the module, which is the whole reason this shim exists.
+ */
+const OMP_PACKAGE = OMP_HARNESS_PACKAGE;
+
+/**
+ * Why the explicitly anchored harness entry is not the one installed beside
+ * omp-conductor, or `undefined` when it is — or when there is nothing to
+ * compare, because this package is running from a source checkout with no
+ * install root of its own.
+ *
+ * The failure it names is silent otherwise (#828): Bun's ambient bare-package
+ * resolution can choose its install cache even when the worker binding is
+ * mounted and inode-current. The production resolver is therefore
+ * {@link resolveHarnessEntry}, rooted at this module's directory; this check
+ * remains the fail-closed attestation that the resolved absolute path stayed
+ * inside the same install.
+ */
+export function harnessOutsideInstall(
+  moduleDir: string = import.meta.dir,
+  resolveSpecifier: (specifier: string) => string = () => resolveHarnessEntry(moduleDir),
+): string | undefined {
+  const root = packageNodeModulesRoot(moduleDir);
+  if (root === undefined) return undefined;
+  let resolved: string;
+  try {
+    const result = resolveSpecifier(OMP_PACKAGE);
+    resolved = result.startsWith("file:") ? fileURLToPath(result) : result;
+  } catch {
+    // Nothing resolved at all. The import below reports that far better than a
+    // guess here could, and reporting it twice in two spellings is worse.
+    return undefined;
+  }
+  if (resolved.startsWith(`${root}/`)) return undefined;
+  return (
+    `omp-conductor could not load its peer dependency ${OMP_PACKAGE} from its own installation: it resolves to ` +
+    `${resolved}, outside ${root}. Refusing Bun's ambient auto-install cache prevents a different harness build ` +
+    "and native addon from standing in for the operator's install. Run `omp-conductor setup host` to verify the " +
+    "worker binding, or install the harness alongside omp-conductor."
+  );
+}
 
 /**
  * The only session surface the dispatcher is allowed to know about: send one
@@ -73,6 +114,39 @@ export interface AgentSessionLike {
    * downgrade, instead of it vanishing and a run just reading dumber.
    */
   modelFallbackMessage?: string;
+  /**
+   * The code-graph session observation (#726): whether the graph MCP tools
+   * were in this session's registry, as a one-shot async fact. The harness
+   * tool registry settles late in a session's life (MCP wiring finalises
+   * after creation), so the in-process session under {@link createLocalSession}
+   * exposes this promise; the session-host child relays the resolved value
+   * over the wire, and the proxy session {@link createSession} exposes the
+   * settled observation as {@link graphTools}. Resolving `undefined` means no
+   * observation could be recorded (surface absent or never readable) — never
+   * "graph tools absent", which is the `present: false` truth value.
+   */
+  graphToolsReady?: Promise<GraphToolsObservation | undefined>;
+  /**
+   * The code-graph session observation (#726): whether the graph MCP tools
+   * were in this session's registry. Set on the proxy session once the child's
+   * relayed observation lands. Absent means no observation was recorded — never
+   * "graph tools absent", which is the `present: false` truth value.
+   */
+  graphTools?: GraphToolsObservation;
+  /**
+   * The version of the omp-conductor module this session process actually
+   * LOADED, attested by the live process at session start (#832): the module
+   * tree this session's tools execute out of, read from the package this
+   * process resolved — never from the package files on disk after the fact.
+   * Absent only when the version cannot be read (a hand-built fake, a
+   * packaging oddity) — absence is not "the newest", and an upgrade that
+   * cannot see the loaded version must not claim the session reloaded.
+   */
+  extensionVersion?: string;
+  /** Absolute entry path of the harness module this session process loaded. */
+  harnessPath?: string;
+  /** Version read from the package owning {@link harnessPath}. */
+  harnessVersion?: string;
 }
 
 /**
@@ -216,15 +290,28 @@ export async function createLocalSession(opts: {
    */
   requireYieldTool?: boolean;
 }): Promise<AgentSessionLike> {
+  let harnessPath: string;
+  try {
+    // An explicit Bun-supported root is the resolver contract. A bare import
+    // from this same bound module was observed selecting the worker's ambient
+    // auto-install cache even while the peer beside it was readable (#828).
+    harnessPath = resolveHarnessEntry(import.meta.dir);
+  } catch (cause) {
+    throw new Error(
+      `omp-conductor could not resolve its peer dependency ${OMP_PACKAGE} from ${import.meta.dir}. Install it alongside omp-conductor (it is deliberately not bundled, so the dispatcher runs the same harness build as the operator).`,
+      { cause },
+    );
+  }
+  const stray = harnessOutsideInstall(import.meta.dir, () => harnessPath);
+  if (stray !== undefined) throw new Error(stray);
   let loaded: unknown;
   try {
-    // Dynamic import is load-bearing, not laziness: the harness is an optional
-    // peer dependency that is absent when this package is type-checked or
-    // published, so a static import would fail the build it must survive.
-    loaded = await import(OMP_PACKAGE as string);
+    // Dynamic import is load-bearing: the runtime-selected absolute path pins
+    // the operator's peer without making it a build-time dependency.
+    loaded = await import(harnessPath);
   } catch (cause) {
     throw new Error(
-      `omp-conductor could not load its peer dependency ${OMP_PACKAGE}. Install it alongside omp-conductor (it is deliberately not bundled, so the dispatcher runs the same harness build as the operator).`,
+      `omp-conductor could not load its peer dependency ${OMP_PACKAGE} from ${harnessPath}. Install it alongside omp-conductor (it is deliberately not bundled, so the dispatcher runs the same harness build as the operator).`,
       { cause },
     );
   }
@@ -329,6 +416,19 @@ export async function createLocalSession(opts: {
   const modelFallbackMessage =
     typeof fallback === "string" && fallback !== "" ? fallback : undefined;
 
+  // The code-graph session observation (#726): whether the graph MCP tools are
+  // in this session's registry. The harness tool registry is structural and
+  // settles late — MCP wiring finalises through a deferred discovery pass after
+  // `createAgentSession` resolves, so the read can throw in the creation
+  // window, and the graph tools surface under the *enabled* names, never the
+  // active ones. `observeGraphTools` polls that surface until it stops
+  // throwing, bounded; an absent surface (older harness build) or an
+  // unreadable one records no observation — a registry answer is never
+  // guessed. The observation resolves asynchronously so the session handshake
+  // never waits for it.
+  const sessionTools = raw as { getEnabledToolNames?: () => string[] };
+  const graphToolsReady = observeGraphTools(sessionTools.getEnabledToolNames?.bind(sessionTools));
+
   // One real subscription fanned out per event type, so N `on()` calls cost one
   // listener on the harness stream and unknown event types cost nothing.
   const handlers = new Map<string, ((e: unknown) => void)[]>();
@@ -339,6 +439,7 @@ export async function createLocalSession(opts: {
     for (const cb of handlers.get("*") ?? []) cb(event);
   });
 
+  const loadedHarnessVersion = harnessVersion(harnessPath);
   const session: AgentSessionLike = {
     prompt: (text, promptOpts) => raw.prompt(text, promptOpts),
     on(event, cb) {
@@ -354,6 +455,12 @@ export async function createLocalSession(opts: {
         raw.abort({ goalReason: "interrupted", reason: "operator pause" }),
       ).then(() => undefined);
     },
+    // The loaded-module attestation (#832): this session process executes the
+    // conductor module it resolved at start; the version is a property of this
+    // process's loaded tree, deliberately not of what is on disk now.
+    ...(conductorModuleVersion() === undefined ? {} : { extensionVersion: conductorModuleVersion() }),
+    harnessPath,
+    ...(loadedHarnessVersion === undefined ? {} : { harnessVersion: loadedHarnessVersion }),
     // The path the session actually opened, never one we asked for: the
     // arm/monitor tooling reads this file as proof of activity, so a path
     // nothing ever writes to is worse than no path at all.
@@ -361,6 +468,7 @@ export async function createLocalSession(opts: {
       return raw.sessionFile;
     },
     ...(modelFallbackMessage === undefined ? {} : { modelFallbackMessage }),
+    graphToolsReady,
   };
 
   disposers.set(session, async () => {
@@ -439,6 +547,28 @@ function asRawSession(created: unknown): RawSession {
 /** Absolute path of the child entrypoint, resolved against this package. */
 export const SESSION_HOST = join(import.meta.dir, "session-host.ts");
 
+/**
+ * The version of the omp-conductor package this *process* loaded — the module
+ * tree this process's session machinery actually executes, read from the
+ * package.json next to `import.meta.dir` (#832). Read once per process and
+ * cached: the upgrade's session-reload proof compares this against the target
+ * release to tell a genuinely reloaded OMP process from a package install the
+ * live session never picked up. `undefined` when the file cannot be read —
+ * absence is a missing attestation, never "the newest".
+ */
+let loadedConductorVersion: string | undefined;
+export function conductorModuleVersion(): string | undefined {
+  if (loadedConductorVersion !== undefined) return loadedConductorVersion;
+  try {
+    const raw = readFileSync(join(import.meta.dir, "..", "package.json"), "utf8");
+    const parsed = JSON.parse(raw) as { version?: unknown };
+    loadedConductorVersion = typeof parsed.version === "string" ? parsed.version : undefined;
+  } catch {
+    loadedConductorVersion = undefined;
+  }
+  return loadedConductorVersion;
+}
+
 /**
  * How long the parent waits for a child to connect and report `ready`.
  *
@@ -625,8 +755,9 @@ export async function createSession(opts: CreateSessionOptions): Promise<AgentSe
       "daemon shutdown began while the session socket was binding",
     );
   }
-  // The socket is the run's own channel, and the daemon's own uid is the only
-  // one that speaks on it.
+  // The socket is the run's own channel, and this process's own uid — the
+  // fleet account every session runs as (#894) — is the only one that speaks
+  // on it.
   chmodSync(socketPath, 0o600);
 
   const spec: SessionHostSpec = {
@@ -646,14 +777,23 @@ export async function createSession(opts: CreateSessionOptions): Promise<AgentSe
   };
 
   const log = opts.onChildLog ?? ((line: string) => process.stderr.write(`${line}\n`));
-  const argv = [process.execPath, opts.hostModule ?? SESSION_HOST, JSON.stringify(spec)];
+  const hostModule = opts.hostModule ?? SESSION_HOST;
+  // The child is the same installed tree this process runs from, launched
+  // under the fleet account (#894). `--no-install` keeps Bun off its ambient
+  // auto-install cache, so the peer and its native addon resolve from the
+  // operator's exact install or fail loudly.
+  const argv = [process.execPath, "--no-install", hostModule, JSON.stringify(spec)];
+  // The session's own role is stamped on the child, so a process the agent
+  // runs — `omp-conductor report` from its sandbox — can tell a worker session
+  // from the operator's shell. Direct CLI runs outside a spawned session
+  // inherit nothing and stay the orchestrator surface.
+  let env: Record<string, string | undefined> | undefined;
+  if (opts.role !== undefined) {
+    env = { ...process.env, [SESSION_ROLE_ENV]: opts.role };
+  }
   const child = Bun.spawn(argv, {
     cwd: opts.cwd,
-    // Stamp the session's own role on the child, so a process the agent runs —
-    // `omp-conductor report` from its sandbox — can tell a worker session from
-    // the operator's shell. Direct CLI runs outside a spawned session inherit
-    // nothing and stay the orchestrator surface.
-    env: opts.role === undefined ? undefined : { ...process.env, [SESSION_ROLE_ENV]: opts.role },
+    env,
     stdin: "ignore",
     // The harness writes progress to stdout; both streams are the daemon's log,
     // never the protocol. The protocol has its own socket precisely so a chatty
@@ -783,6 +923,10 @@ export async function createSession(opts: CreateSessionOptions): Promise<AgentSe
   const pending = new Map<number, { resolve: () => void; reject: (err: Error) => void }>();
   let sessionFile: string | undefined;
   let modelFallbackMessage: string | undefined;
+  let graphTools: GraphToolsObservation | undefined;
+  let extensionVersion: string | undefined;
+  let loadedHarnessPath: string | undefined;
+  let loadedHarnessVersion: string | undefined;
   let promptSeq = 0;
 
   const { promise: ready, resolve: onReady, reject: onReadyFail } = Promise.withResolvers<void>();
@@ -886,8 +1030,14 @@ export async function createSession(opts: CreateSessionOptions): Promise<AgentSe
         case "ready":
           sessionFile = message.sessionFile;
           modelFallbackMessage = message.modelFallbackMessage;
+          extensionVersion = message.extensionVersion;
+          loadedHarnessPath = message.harnessPath;
+          loadedHarnessVersion = message.harnessVersion;
           onReady();
           break;
+        case "graph-tools":
+          graphTools = message.graphTools;
+          break;
         case "start-error":
           fail(message.message);
           break;
@@ -981,6 +1131,18 @@ export async function createSession(opts: CreateSessionOptions): Promise<AgentSe
     get modelFallbackMessage() {
       return modelFallbackMessage;
     },
+    get graphTools() {
+      return graphTools;
+    },
+    get extensionVersion() {
+      return extensionVersion;
+    },
+    get harnessPath() {
+      return loadedHarnessPath;
+    },
+    get harnessVersion() {
+      return loadedHarnessVersion;
+    },
   };
 
   disposers.set(session, async () => {