nolo-cli 0.1.32 → 0.1.33

package/cli/agentInternalCommandEntries.ts

@@ -1,13 +1,7 @@
 import { runAgentListCommand } from "./agentListCommands";
-import { runAgentCreateCustomCommand } from "./agentCreateCustomCommands";
-import { runAgentDialogsCommand } from "./agentDialogsCommands";
-import { runAgentDoctorCommand } from "./agentDoctorCommands";
-import { runAgentUnpublishCommand } from "./agentUnpublishCommands";
-import { runAgentSuperviseCommand } from "./agentSuperviseCommands";
 import {
   runAgentBindCurrentCommand,
   runAgentRuntimeDoctorCommand,
-  runAgentSmokeBoundCommand,
   runAgentSmokeCurrentCommand,
 } from "./agentMachineCommands";
 import { runAgentPullCommand } from "./agentPullCommand";
@@ -17,27 +11,22 @@ import {
 } from "./agentRecordCommands";
 import { runAgentRunCommand } from "./agentRunCommand";
 import {
-  createArgsCommand,
   createEnvCommand,
   createEnvScriptDirCommand,
 } from "./cliCommandFactories";
 import type { CommandEntry } from "./cliCommandTypes";
+import { runSetupOfflineMarxistsAgentCommand } from "./offlineMarxistsAgentCommand";
 
 export function getAgentInternalCommandEntries(): CommandEntry[] {
   return [
     createEnvScriptDirCommand(["chat"], "Chat with an agent", runAgentRunCommand),
-    createEnvCommand(["agent", "create-custom"], "Create a custom coding agent", runAgentCreateCustomCommand),
     createEnvCommand(["agent", "list"], "List owned agents", runAgentListCommand),
-    createEnvCommand(["agent", "dialogs"], "Inspect recent dialogs for an agent", runAgentDialogsCommand),
-    createEnvCommand(["agent", "doctor"], "Audit agent workspace health", runAgentDoctorCommand),
-    createEnvCommand(["agent", "unpublish"], "Remove an agent's public record", runAgentUnpublishCommand),
     createEnvCommand(["agent", "pull"], "Cache an agent for local runs", runAgentPullCommand),
     createEnvCommand(["agent", "read"], "Read a single agent", runAgentReadCommand),
     createEnvScriptDirCommand(["agent", "run"], "Run an agent", runAgentRunCommand),
-    createArgsCommand(["agent", "supervise"], "Run an agent in autonomous cycles", runAgentSuperviseCommand),
+    createEnvCommand(["agent", "setup-offline-marxists"], "Create or update the Marxists.org offline book agent", runSetupOfflineMarxistsAgentCommand),
     createEnvCommand(["agent", "update"], "Update agent fields", runAgentUpdateCommand),
     createEnvCommand(["agent", "bind-current"], "Bind an agent to this machine", runAgentBindCurrentCommand),
-    createEnvCommand(["agent", "smoke-bound"], "Smoke test an agent through its existing runtime binding", runAgentSmokeBoundCommand),
     createEnvCommand(["agent", "smoke-current"], "Smoke test a bound agent through this machine", runAgentSmokeCurrentCommand),
     createEnvCommand(["agent", "runtime-doctor"], "Diagnose current machine runtime compatibility", runAgentRuntimeDoctorCommand),
     createEnvScriptDirCommand(["agent", "chat"], "Chat with an agent", runAgentRunCommand),

package/cli/agentListCommands.ts

@@ -12,10 +12,8 @@ import {
 import {
   parseUserIdFromAuthToken,
   resolveAuthToken,
-  resolveServerCandidates,
   resolveServerUrl,
 } from "./cliEnvHelpers";
-import { readFromServerCandidates, readThroughList } from "./hybridReadHelpers";
 
 export async function runAgentListCommand(
   args: string[],
@@ -25,7 +23,7 @@ export async function runAgentListCommand(
   const output = deps.output ?? process.stdout;
   const { wantJson, publicOnly, idsOnly, includeLegacy } = parseAgentListArgs(args);
 
-  const authToken = resolveAuthToken(args, env);
+  const authToken = resolveAuthToken(env);
   if (!authToken) {
     output.write("[nolo] agent list requires an auth token. Run `nolo login` or set AUTH_TOKEN.\n");
     return 1;
@@ -40,34 +38,27 @@ export async function runAgentListCommand(
   const db = deps.db ?? await getReadableCliDb(output);
   const fetchImpl = deps.fetchImpl ?? fetch;
   const fallbackFetchImpl = deps.fallbackFetchImpl;
-  const serverUrl = resolveServerUrl(args, env);
-  const serverCandidates = resolveServerCandidates(args, env, serverUrl);
 
   try {
-    const loadRemoteAgents = async () => {
-      const remote = await readFromServerCandidates({
-        serverCandidates,
-        readRemote: (candidateUrl) =>
-          listRemoteAgents({
-            authToken,
-            fallbackFetchImpl,
-            fetchImpl,
-            includeLegacy,
-            serverUrl: candidateUrl,
-            userId,
-            queryUserRecords,
-            readDbRecord,
-          }),
+    let agents: ListedAgent[];
+    let source: "local-cache" | "remote-cache";
+    try {
+      agents = await listLocalCachedAgents({ db, userId });
+      source = "local-cache";
+    } catch {
+      const serverUrl = resolveServerUrl(env);
+      agents = await listRemoteAgents({
+        authToken,
+        fallbackFetchImpl,
+        fetchImpl,
+        includeLegacy,
+        serverUrl,
+        userId,
+        queryUserRecords,
+        readDbRecord,
       });
-      return remote.value;
-    };
-
-    const result = await readThroughList({
-      readLocal: () => listLocalCachedAgents({ db, userId }),
-      readRemote: loadRemoteAgents,
-    });
-    let agents = result.items;
-    const source = result.source;
+      source = "remote-cache";
+    }
 
     if (!includeLegacy) {
       agents = agents.filter((agent) => !agent.privateKey.startsWith("cybot-"));

package/cli/agentMachineCommands.ts

@@ -1,19 +1,13 @@
 import type { MachineHeartbeat } from "../connector-experimental/protocol";
 import { resolveConnectorWebSocketTarget } from "./connectorWebSocketTarget";
-import {
-  buildCurrentUserPlatformAgentCandidateKeys,
-  resolveCliAgentKeyInput,
-} from "./agentAliases";
+import { resolveCliAgentKeyInput } from "./agentAliases";
 import {
   type AgentCommandDeps,
-  getReadableCliDb,
   type LocalCliExecutor,
   type SmokeWebSocketOptions,
 } from "./agentCommandSupport";
-import { buildConnectorCliPrompt } from "./machineCommandPrompts";
 import {
   readAgentRecord,
-  resolveAgentRecordFromHybridStore,
   writeAgentRecord,
 } from "./agentRecordHelpers";
 import {
@@ -34,26 +28,15 @@ async function defaultExecuteCli(
 }
 
 async function forwardConnectorRunMessage(
-  _machine: MachineHeartbeat,
+  machine: MachineHeartbeat,
   message: string,
   pushMessage: (response: string) => void,
   executeCli: LocalCliExecutor,
   env: EnvLike,
-  fetchImpl: typeof fetch,
-  dispatchDeps?: AgentCommandDeps["connectorRunDispatchDeps"],
+  fetchImpl: typeof fetch
 ) {
-  const { handleConnectorRunMessage } = await import("./machineWsRunDispatch");
-  return handleConnectorRunMessage(
-    message,
-    pushMessage,
-    executeCli,
-    env,
-    fetchImpl,
-    {
-      buildConnectorCliPrompt,
-      ...(dispatchDeps ?? {}),
-    },
-  );
+  const { handleConnectorRunMessage } = await import("./machineCommands");
+  return handleConnectorRunMessage(machine, message, pushMessage, executeCli, env, fetchImpl);
 }
 
 async function detectLaunchableMachineInfo() {
@@ -86,16 +69,9 @@ function shouldRuntimeDoctorPass(args: {
   runtimeClass: string;
   requiredCapability: string;
   hasCapability: boolean;
-  bindingRequired: boolean;
-  isBoundToCurrent: boolean;
-  isBindingOwnerCompatible: boolean;
 }) {
   if (args.runtimeClass !== "cli-machine") return args.runtimeClass !== "unknown";
-  return Boolean(
-    args.requiredCapability &&
-      args.hasCapability &&
-      (!args.bindingRequired || (args.isBoundToCurrent && args.isBindingOwnerCompatible))
-  );
+  return Boolean(args.requiredCapability && args.hasCapability);
 }
 
 function assertSmokeCompatible(agent: any, machine: MachineHeartbeat) {
@@ -116,46 +92,6 @@ function assertSmokeCompatible(agent: any, machine: MachineHeartbeat) {
   }
 }
 
-function runtimeBindingFacts(agent: any, machine: MachineHeartbeat, currentUserId?: string) {
-  const runtimeBinding = agent?.runtimeBinding && typeof agent.runtimeBinding === "object"
-    ? agent.runtimeBinding
-    : {};
-  const boundMachineId = typeof runtimeBinding.machineId === "string"
-    ? runtimeBinding.machineId.trim()
-    : "";
-  const boundOwnerUserId = typeof runtimeBinding.ownerUserId === "string"
-    ? runtimeBinding.ownerUserId.trim()
-    : "";
-  const bindingRequired = agent?.apiSource === "cli";
-  return {
-    bindingRequired,
-    boundMachineId,
-    boundOwnerUserId,
-    isBoundToCurrent: Boolean(boundMachineId) && boundMachineId === machine.machineId,
-    isBindingOwnerCompatible: !boundOwnerUserId || !currentUserId || boundOwnerUserId === currentUserId,
-  };
-}
-
-function assertSmokeBindingState(args: {
-  agent: any;
-  machine: MachineHeartbeat;
-  currentUserId: string;
-  allowRebind: boolean;
-}) {
-  const facts = runtimeBindingFacts(args.agent, args.machine, args.currentUserId);
-  if (args.allowRebind || !facts.bindingRequired) return;
-  if (facts.boundMachineId && !facts.isBoundToCurrent) {
-    throw new Error(
-      `Agent ${args.agent?.name ?? args.agent?.dbKey ?? "unknown"} is bound to ${facts.boundMachineId}, not current machine ${args.machine.machineId}. Run \`nolo agent bind-current ${args.agent?.dbKey ?? "AGENT_KEY"}\` first or pass --bind to rebind explicitly.`
-    );
-  }
-  if (facts.boundOwnerUserId && !facts.isBindingOwnerCompatible) {
-    throw new Error(
-      `Agent ${args.agent?.name ?? args.agent?.dbKey ?? "unknown"} is bound for owner ${facts.boundOwnerUserId}, not current user ${args.currentUserId}. \`nolo agent smoke-current\` only validates a connector launched under your current auth token, so it cannot simulate another owner's binding. If you intend to use the existing shared binding, run \`nolo agent run ${args.agent?.dbKey ?? "AGENT_KEY"}\` and make sure owner ${facts.boundOwnerUserId} has a live connector online. If you intend to take ownership of the binding on this account, run \`nolo agent bind-current ${args.agent?.dbKey ?? "AGENT_KEY"}\` first or pass --bind explicitly.`
-    );
-  }
-}
-
 const CONNECTOR_WS_KEEPALIVE_MS = 25_000;
 
 function buildConnectorKeepaliveMessage() {
@@ -230,75 +166,19 @@ async function heartbeatCurrentMachine(args: {
   }
 }
 
-async function resolveMachineAgent(args: {
-  agentInput: string;
-  cliArgs: string[];
-  deps: AgentCommandDeps;
-  env: EnvLike;
-  fetchImpl: typeof fetch;
-  fallbackFetchImpl?: typeof fetch;
-  output: typeof process.stdout | { write: (chunk: string) => void };
-  userId: string;
-}) {
-  const fallbackKey = resolveCliAgentKeyInput(args.agentInput);
-  const candidateKeys = buildCurrentUserPlatformAgentCandidateKeys(args.agentInput, args.userId);
-  if (candidateKeys.length === 0 || candidateKeys[0] === fallbackKey) {
-    return { agentKey: fallbackKey };
-  }
-
-  try {
-    const db = args.deps.db ?? await getReadableCliDb(args.output as any);
-    const resolved = await resolveAgentRecordFromHybridStore({
-      agentInput: args.agentInput,
-      cliArgs: args.cliArgs,
-      env: args.env,
-      db,
-      fetchImpl: args.fetchImpl,
-      fallbackFetchImpl: args.fallbackFetchImpl,
-    });
-    return resolved
-      ? {
-          agentKey: resolved.agentKey,
-          record: resolved.record,
-          source: resolved.source,
-        }
-      : { agentKey: fallbackKey };
-  } catch {
-    return { agentKey: fallbackKey };
-  }
-}
-
-async function readResolvedAgentRecord(args: {
-  authToken: string;
-  fallbackFetchImpl?: typeof fetch;
-  fetchImpl: typeof fetch;
-  resolvedAgent: Awaited<ReturnType<typeof resolveMachineAgent>>;
-  serverUrl: string;
-}) {
-  return args.resolvedAgent.source === "remote-cache"
-    ? args.resolvedAgent.record
-    : await readAgentRecord({
-        agentKey: args.resolvedAgent.agentKey,
-        authToken: args.authToken,
-        fallbackFetchImpl: args.fallbackFetchImpl,
-        fetchImpl: args.fetchImpl,
-        serverUrl: args.serverUrl,
-      });
-}
-
 export async function runAgentBindCurrentCommand(
   args: string[],
   deps: AgentCommandDeps = {}
 ) {
   const env = deps.env ?? process.env;
   const output = deps.output ?? process.stdout;
-  const agentInput = args[0]?.trim();
-  if (!agentInput || agentInput === "--help" || agentInput === "-h") {
+  const agentKey = args[0]?.trim();
+  if (!agentKey || agentKey === "--help" || agentKey === "-h") {
     output.write("Usage: nolo agent bind-current <agentKey>\n");
-    return agentInput ? 0 : 1;
+    return agentKey ? 0 : 1;
   }
 
-  const authToken = resolveAuthToken(args, env);
+  const authToken = resolveAuthToken(env);
   if (!authToken) {
     output.write("[nolo] agent bind-current requires an auth token. Run `nolo login` or set AUTH_TOKEN.\n");
     return 1;
@@ -310,28 +190,14 @@ export async function runAgentBindCurrentCommand(
     return 1;
   }
 
-  const serverUrl = resolveServerUrl(args, env);
+  const serverUrl = resolveServerUrl(env);
   const fetchImpl = deps.fetchImpl ?? fetch;
   const fallbackFetchImpl = deps.fallbackFetchImpl;
-  const resolvedAgent = await resolveMachineAgent({
-    agentInput,
-    cliArgs: args,
-    deps,
-    env,
-    fetchImpl,
-    fallbackFetchImpl,
-    output,
-    userId,
-  });
-  const agentKey = resolvedAgent.agentKey;
   const machine = await (deps.machineInfo ?? detectLaunchableMachineInfo)();
 
   try {
     await heartbeatCurrentMachine({ authToken, fetchImpl, machine, serverUrl });
-    const existing =
-      resolvedAgent.source === "remote-cache"
-        ? resolvedAgent.record
-        : await readAgentRecord({ agentKey, authToken, fallbackFetchImpl, fetchImpl, serverUrl });
+    const existing = await readAgentRecord({ agentKey, authToken, fallbackFetchImpl, fetchImpl, serverUrl });
     const updated = {
       ...existing,
       runtimeBinding: {
@@ -372,13 +238,13 @@ export async function runAgentSmokeCurrentCommand(
   const env = deps.env ?? process.env;
   const output = deps.output ?? process.stdout;
   const agentInput = args[0]?.trim();
-  const allowRebind = args.includes("--bind");
   if (!agentInput || agentInput === "--help" || agentInput === "-h") {
-    output.write("Usage: nolo agent smoke-current <agent> [--msg \"hello\"] [--bind]\n");
+    output.write("Usage: nolo agent smoke-current <agent> --msg \"hello\"\n");
     return agentInput ? 0 : 1;
   }
+  const agentKey = resolveCliAgentKeyInput(agentInput);
 
-  const authToken = resolveAuthToken(args, env);
+  const authToken = resolveAuthToken(env);
   if (!authToken) {
     output.write("[nolo] agent smoke-current requires an auth token. Run `nolo login` or set AUTH_TOKEN.\n");
     return 1;
@@ -390,60 +256,35 @@ export async function runAgentSmokeCurrentCommand(
   }
 
   const userInput = readOption(args, "--msg") ?? "Smoke test from nolo connector.";
-  const serverUrl = resolveServerUrl(args, env);
+  const serverUrl = resolveServerUrl(env);
   const fetchImpl = deps.fetchImpl ?? fetch;
   const fallbackFetchImpl = deps.fallbackFetchImpl;
-  const resolvedAgent = await resolveMachineAgent({
-    agentInput,
-    cliArgs: args,
-    deps,
-    env,
-    fetchImpl,
-    fallbackFetchImpl,
-    output,
-    userId,
-  });
-  const agentKey = resolvedAgent.agentKey;
   const machine = await (deps.machineInfo ?? detectLaunchableMachineInfo)();
   const sentMessages: string[] = [];
 
   try {
     await heartbeatCurrentMachine({ authToken, fetchImpl, machine, serverUrl });
-    const existing = await readResolvedAgentRecord({
+    const existing = await readAgentRecord({ agentKey, authToken, fallbackFetchImpl, fetchImpl, serverUrl });
+    assertSmokeCompatible(existing, machine);
+    await writeAgentRecord({
+      agentKey,
       authToken,
       fallbackFetchImpl,
       fetchImpl,
-      resolvedAgent,
       serverUrl,
-    });
-    assertSmokeCompatible(existing, machine);
-    assertSmokeBindingState({
-      agent: existing,
-      machine,
-      currentUserId: userId,
-      allowRebind,
-    });
-    if (allowRebind) {
-      await writeAgentRecord({
-        agentKey,
-        authToken,
-        fallbackFetchImpl,
-        fetchImpl,
-        serverUrl,
-        userId,
-        record: {
-          ...existing,
-          runtimeBinding: {
-            ...(existing?.runtimeBinding && typeof existing.runtimeBinding === "object"
-              ? existing.runtimeBinding
-              : {}),
-            machineId: machine.machineId,
-            ownerUserId: userId,
-          },
-          updatedAt: Date.now(),
+      userId,
+      record: {
+        ...existing,
+        runtimeBinding: {
+          ...(existing?.runtimeBinding && typeof existing.runtimeBinding === "object"
+            ? existing.runtimeBinding
+            : {}),
+          machineId: machine.machineId,
+          ownerUserId: userId,
         },
-      });
-    }
+        updatedAt: Date.now(),
+      },
+    });
 
     let runResponse: any = null;
     const wsTarget = await resolveConnectorWebSocketTarget({
@@ -470,8 +311,7 @@ export async function runAgentSmokeCurrentCommand(
             AUTH_TOKEN: authToken,
             NOLO_MACHINE_API_KEY: authToken,
           },
-          fetchImpl,
-          deps.connectorRunDispatchDeps,
+          fetchImpl
         ),
         onOpen: async () => {
           const res = await fetchImpl(`${serverUrl}/api/agent/run`, {
@@ -506,106 +346,6 @@ export async function runAgentSmokeCurrentCommand(
   }
 }
 
-export async function runAgentSmokeBoundCommand(
-  args: string[],
-  deps: AgentCommandDeps = {}
-) {
-  const env = deps.env ?? process.env;
-  const output = deps.output ?? process.stdout;
-  const agentInput = args[0]?.trim();
-  if (!agentInput || agentInput === "--help" || agentInput === "-h") {
-    output.write("Usage: nolo agent smoke-bound <agent> [--msg \"hello\"]\n");
-    return agentInput ? 0 : 1;
-  }
-
-  const authToken = resolveAuthToken(args, env);
-  if (!authToken) {
-    output.write("[nolo] agent smoke-bound requires an auth token. Run `nolo login` or set AUTH_TOKEN.\n");
-    return 1;
-  }
-  const userId = parseUserIdFromAuthToken(authToken);
-  if (!userId) {
-    output.write("[nolo] agent smoke-bound could not read userId from AUTH_TOKEN.\n");
-    return 1;
-  }
-
-  const userInput = readOption(args, "--msg") ?? "Smoke test existing bound runtime from nolo.";
-  const serverUrl = resolveServerUrl(args, env);
-  const fetchImpl = deps.fetchImpl ?? fetch;
-  const fallbackFetchImpl = deps.fallbackFetchImpl;
-  const resolvedAgent = await resolveMachineAgent({
-    agentInput,
-    cliArgs: args,
-    deps,
-    env,
-    fetchImpl,
-    fallbackFetchImpl,
-    output,
-    userId,
-  });
-  const agentKey = resolvedAgent.agentKey;
-
-  try {
-    const existing = await readResolvedAgentRecord({
-      authToken,
-      fallbackFetchImpl,
-      fetchImpl,
-      resolvedAgent,
-      serverUrl,
-    });
-    const facts = runtimeBindingFacts(existing, { machineId: "", name: "", platform: "", arch: "", capabilities: [] }, userId);
-    if (!facts.boundMachineId) {
-      throw new Error(
-        `Agent ${existing?.name ?? existing?.dbKey ?? agentKey} is not currently bound to a machine. Run \`nolo agent bind-current ${agentKey}\` first.`
-      );
-    }
-    if (!facts.boundOwnerUserId) {
-      throw new Error(
-        `Agent ${existing?.name ?? existing?.dbKey ?? agentKey} is missing runtimeBinding.ownerUserId for machine ${facts.boundMachineId}.`
-      );
-    }
-
-    const res = await fetchImpl(`${serverUrl}/api/agent/run`, {
-      method: "POST",
-      headers: {
-        Authorization: `Bearer ${authToken}`,
-        "Content-Type": "application/json",
-      },
-      body: JSON.stringify({
-        agentKey,
-        userInput,
-        stream: false,
-      }),
-    });
-    const body = await res.json().catch(() => ({}));
-    if (!res.ok) {
-      const errorMessage = typeof body?.error === "string" ? body.error : `HTTP ${res.status}`;
-      const detailMessage = typeof body?.message === "string" ? body.message : "";
-      const reason = typeof body?.reason === "string" ? body.reason : "";
-      throw new Error(
-        [
-          `agent run failed: ${errorMessage}`,
-          detailMessage,
-          reason ? `reason=${reason}` : "",
-        ].filter(Boolean).join("\n")
-      );
-    }
-
-    output.write(
-      `Bound run OK: ${body?.dialogId ?? "no-dialog"}\nAgent key: ${agentKey}\nBound owner: ${facts.boundOwnerUserId}\nBound machine: ${facts.boundMachineId}\n`
-    );
-    if (body?.content) output.write(`${body.content}\n`);
-    return 0;
-  } catch (error) {
-    output.write(
-      `[nolo] agent smoke-bound failed: ${
-        error instanceof Error ? error.message : String(error)
-      }\n`
-    );
-    return 1;
-  }
-}
-
 export async function runAgentRuntimeDoctorCommand(
   args: string[],
   deps: AgentCommandDeps = {}
@@ -617,45 +357,27 @@ export async function runAgentRuntimeDoctorCommand(
     output.write("Usage: nolo agent runtime-doctor <agentKey>\n");
     return agentInput ? 0 : 1;
   }
+  const agentKey = resolveCliAgentKeyInput(agentInput);
 
-  const authToken = resolveAuthToken(args, env);
+  const authToken = resolveAuthToken(env);
   if (!authToken) {
     output.write("[nolo] agent runtime-doctor requires an auth token. Run `nolo login` or set AUTH_TOKEN.\n");
     return 1;
   }
-  const userId = parseUserIdFromAuthToken(authToken);
-  if (!userId) {
-    output.write("[nolo] agent runtime-doctor could not read userId from AUTH_TOKEN.\n");
-    return 1;
-  }
 
-  const serverUrl = resolveServerUrl(args, env);
+  const serverUrl = resolveServerUrl(env);
   const fetchImpl = deps.fetchImpl ?? fetch;
   const fallbackFetchImpl = deps.fallbackFetchImpl;
-  const resolvedAgent = await resolveMachineAgent({
-    agentInput,
-    cliArgs: args,
-    deps,
-    env,
-    fetchImpl,
-    fallbackFetchImpl,
-    output,
-    userId,
-  });
-  const agentKey = resolvedAgent.agentKey;
   const machine = await (deps.machineInfo ?? detectLaunchableMachineInfo)();
 
   try {
-    const agent =
-      resolvedAgent.source === "remote-cache"
-        ? resolvedAgent.record
-        : await readAgentRecord({ agentKey, authToken, fallbackFetchImpl, fetchImpl, serverUrl });
+    const agent = await readAgentRecord({ agentKey, authToken, fallbackFetchImpl, fetchImpl, serverUrl });
     const requiredCapability = requiredCapabilityForAgent(agent);
     const runtimeClass = classifyAgentRuntime(agent);
+    const isBoundToCurrent = agent?.runtimeBinding?.machineId === machine.machineId;
     const hasCapability = requiredCapability
       ? machine.capabilities.includes(requiredCapability)
       : false;
-    const bindingFacts = runtimeBindingFacts(agent, machine, userId);
     output.write(`Agent runtime doctor: ${agent?.name ?? agentKey}\n`);
     if (agentInput !== agentKey) output.write(`Agent input: ${agentInput}\n`);
     output.write(`Agent key: ${agentKey}\n`);
@@ -665,28 +387,10 @@ export async function runAgentRuntimeDoctorCommand(
     output.write(`Required capability: ${requiredCapability || "none"}\n`);
     output.write(`Current machine: ${machine.name} (${machine.machineId})\n`);
     output.write(`Current machine capabilities: ${machine.capabilities.length ? machine.capabilities.join(", ") : "none"}\n`);
-    output.write(`Recorded bound machine: ${bindingFacts.boundMachineId || "none"}\n`);
-    output.write(`Recorded binding owner: ${bindingFacts.boundOwnerUserId || "unknown"}\n`);
-    output.write(`Current machine binding: ${runtimeClass === "cli-machine" ? (bindingFacts.isBoundToCurrent ? "yes" : "no") : "not required"}\n`);
-    output.write(
-      `Binding owner matches current user: ${
-        runtimeClass === "cli-machine"
-          ? (bindingFacts.boundOwnerUserId
-            ? (bindingFacts.isBindingOwnerCompatible ? "yes" : "no")
-            : "unknown")
-          : "not required"
-      }\n`
-    );
+    output.write(`Current machine binding: ${runtimeClass === "cli-machine" ? (isBoundToCurrent ? "yes" : "no") : "not required"}\n`);
     output.write(`Current machine has required capability: ${requiredCapability ? (hasCapability ? "yes" : "no") : "not required"}\n`);
 
-    return shouldRuntimeDoctorPass({
-      runtimeClass,
-      requiredCapability,
-      hasCapability,
-      bindingRequired: bindingFacts.bindingRequired,
-      isBoundToCurrent: bindingFacts.isBoundToCurrent,
-      isBindingOwnerCompatible: bindingFacts.isBindingOwnerCompatible,
-    }) ? 0 : 1;
+    return shouldRuntimeDoctorPass({ runtimeClass, requiredCapability, hasCapability }) ? 0 : 1;
   } catch (error) {
     output.write(
       `[nolo] agent runtime-doctor failed: ${