nolo-cli 0.1.31 → 0.1.32

package/README.md

@@ -100,6 +100,7 @@ nolo space read 01KKY77TT0DA9NY7TNW3R7255N --content-key page-user-id --brief
 nolo agent list --json
 nolo agent bind-current agent-user-1-agent-1
 nolo agent runtime-doctor agent-user-1-agent-1
+nolo agent smoke-bound agent-user-1-agent-1 --msg "ping"
 nolo agent smoke-current agent-user-1-agent-1 --msg "ping"
 nolo chat --agent agent-pub-01APPBUILDER00000001YAII3I --msg "你好"
 ```
@@ -152,6 +153,7 @@ Run a one-command connector smoke test:
 
 ```bash
 nolo agent runtime-doctor <agentKey>
+nolo agent smoke-bound <agentKey> --msg "ping"
 nolo agent smoke-current <agentKey> --msg "ping"
 ```
 
@@ -159,6 +161,10 @@ nolo agent smoke-current <agentKey> --msg "ping"
 machine has the required CLI capability. `smoke-current` heartbeats the current
 machine, binds the agent to it, opens a temporary connector websocket, calls
 `/api/agent/run`, and prints the returned dialog id/content.
+`smoke-bound` does not start a local connector or rebind anything. It validates
+the agent through its existing runtime binding by calling the real
+`/api/agent/run` path, so it is the safer probe for shared-Space member runs
+that should execute through another owner's online connector.
 
 ## Product Shape
 

package/agentAliases.ts

@@ -14,6 +14,13 @@ export const NOLO_REVIEW_AGENT_ID = "01CODEXCLIMAIN00000001OK";
 export const NOLO_REVIEW_AGENT_KEY =
   `agent-${PLATFORM_DEMO_USER_ID}-${NOLO_REVIEW_AGENT_ID}`;
 
+type PlatformAgentAliasSpec = {
+  agentId: string;
+  canonicalKey: string;
+  aliases: string[];
+  preferCurrentUserCopy?: boolean;
+};
+
 const AGENT_ALIAS_TO_KEY: Record<string, string> = {
   "nolo-frontend": FRONTEND_IMPLEMENTER_AGENT_KEY,
   "frontend-implementer": FRONTEND_IMPLEMENTER_AGENT_KEY,
@@ -36,6 +43,41 @@ const AGENT_ALIAS_TO_KEY: Record<string, string> = {
   "nolo 代码审查": NOLO_REVIEW_AGENT_KEY,
 };
 
+const PLATFORM_AGENT_ALIAS_SPECS: PlatformAgentAliasSpec[] = [
+  {
+    agentId: FRONTEND_IMPLEMENTER_AGENT_ID,
+    canonicalKey: FRONTEND_IMPLEMENTER_AGENT_KEY,
+    aliases: [
+      "nolo-frontend",
+      "frontend-implementer",
+      "frontend-agent",
+      "frontend",
+      "front-end",
+      "前端",
+      "前端实现员",
+    ],
+    preferCurrentUserCopy: true,
+  },
+  {
+    agentId: NOLO_FULLSTACK_AGENT_ID,
+    canonicalKey: NOLO_FULLSTACK_AGENT_KEY,
+    aliases: ["nolo-fullstack", "fullstack", "full-stack", "全栈", "nolo 全栈工程师"],
+  },
+  {
+    agentId: NOLO_REVIEW_AGENT_ID,
+    canonicalKey: NOLO_REVIEW_AGENT_KEY,
+    aliases: [
+      "nolo-reviewer",
+      "reviewer",
+      "nolo-code-review",
+      "code-review",
+      "review",
+      "代码审查",
+      "nolo 代码审查",
+    ],
+  },
+];
+
 function normalizeAlias(raw: string) {
   return raw.trim().toLowerCase();
 }
@@ -53,6 +95,36 @@ export function resolveAgentKeyAlias(raw: string): string | undefined {
   return AGENT_ALIAS_TO_KEY[normalizeAlias(raw)];
 }
 
+export function buildPrivateAgentKey(userId: string, agentId: string) {
+  return `agent-${userId}-${agentId}`;
+}
+
+export function resolvePlatformAgentAliasSpec(raw: string): PlatformAgentAliasSpec | undefined {
+  const normalized = normalizeAlias(raw);
+  return PLATFORM_AGENT_ALIAS_SPECS.find((spec) => spec.aliases.includes(normalized));
+}
+
+export function buildCurrentUserPlatformAgentCandidateKeys(raw: string, userId?: string) {
+  const spec = resolvePlatformAgentAliasSpec(raw);
+  if (!spec) return [];
+
+  const keys: string[] = [];
+  const normalizedUserId = userId?.trim();
+  if (spec.preferCurrentUserCopy && normalizedUserId) {
+    keys.push(buildPrivateAgentKey(normalizedUserId, spec.agentId));
+  }
+  keys.push(spec.canonicalKey);
+  return Array.from(new Set(keys));
+}
+
+export function isKnownPlatformAgentKey(raw?: string) {
+  const trimmed = raw?.trim();
+  if (!trimmed) return false;
+  return PLATFORM_AGENT_ALIAS_SPECS.some(
+    (spec) => trimmed === spec.agentId || trimmed.endsWith(`-${spec.agentId}`)
+  );
+}
+
 export function resolveCliAgentKeyInput(raw: string): string {
   return resolveAgentKeyAlias(raw) ?? parseAgentKeyFromInput(raw);
 }

package/agentCommandSupport.ts

@@ -2,6 +2,7 @@ import type { MachineHeartbeat } from "./connector-experimental/protocol";
 import type { CliKvDb } from "./client/hybridRecordStore";
 import type { EnvLike } from "./cliEnvHelpers";
 import type { OutputLike } from "./cliIoTypes";
+import type { MachineWsRunDispatchDeps } from "./machineWsRunDispatch";
 export type { OutputLike } from "./cliIoTypes";
 
 export type SmokeWebSocketOptions = {
@@ -40,8 +41,10 @@ export type AgentCommandDeps = {
     pushMessage: (response: string) => void,
     executeCli: LocalCliExecutor,
     env: EnvLike,
-    fetchImpl: typeof fetch
+    fetchImpl: typeof fetch,
+    dispatchDeps?: MachineWsRunDispatchDeps,
   ) => Promise<void>;
+  connectorRunDispatchDeps?: MachineWsRunDispatchDeps;
   localRuntimeProbe?: (env: EnvLike) => Promise<LocalRuntimeProbeResult>;
 };
 

package/agentInternalCommandEntries.ts

@@ -7,6 +7,7 @@ import { runAgentSuperviseCommand } from "./agentSuperviseCommands";
 import {
   runAgentBindCurrentCommand,
   runAgentRuntimeDoctorCommand,
+  runAgentSmokeBoundCommand,
   runAgentSmokeCurrentCommand,
 } from "./agentMachineCommands";
 import { runAgentPullCommand } from "./agentPullCommand";
@@ -36,6 +37,7 @@ export function getAgentInternalCommandEntries(): CommandEntry[] {
     createArgsCommand(["agent", "supervise"], "Run an agent in autonomous cycles", runAgentSuperviseCommand),
     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/agentMachineCommands.ts

@@ -1,13 +1,19 @@
 import type { MachineHeartbeat } from "./connector-experimental/protocol";
 import { resolveConnectorWebSocketTarget } from "./connectorWebSocketTarget";
-import { resolveCliAgentKeyInput } from "./agentAliases";
+import {
+  buildCurrentUserPlatformAgentCandidateKeys,
+  resolveCliAgentKeyInput,
+} from "./agentAliases";
 import {
   type AgentCommandDeps,
+  getReadableCliDb,
   type LocalCliExecutor,
   type SmokeWebSocketOptions,
 } from "./agentCommandSupport";
+import { buildConnectorCliPrompt } from "./machineCommandPrompts";
 import {
   readAgentRecord,
+  resolveAgentRecordFromHybridStore,
   writeAgentRecord,
 } from "./agentRecordHelpers";
 import {
@@ -28,15 +34,26 @@ async function defaultExecuteCli(
 }
 
 async function forwardConnectorRunMessage(
-  machine: MachineHeartbeat,
+  _machine: MachineHeartbeat,
   message: string,
   pushMessage: (response: string) => void,
   executeCli: LocalCliExecutor,
   env: EnvLike,
-  fetchImpl: typeof fetch
+  fetchImpl: typeof fetch,
+  dispatchDeps?: AgentCommandDeps["connectorRunDispatchDeps"],
 ) {
-  const { handleConnectorRunMessage } = await import("./machineCommands");
-  return handleConnectorRunMessage(machine, message, pushMessage, executeCli, env, fetchImpl);
+  const { handleConnectorRunMessage } = await import("./machineWsRunDispatch");
+  return handleConnectorRunMessage(
+    message,
+    pushMessage,
+    executeCli,
+    env,
+    fetchImpl,
+    {
+      buildConnectorCliPrompt,
+      ...(dispatchDeps ?? {}),
+    },
+  );
 }
 
 async function detectLaunchableMachineInfo() {
@@ -134,7 +151,7 @@ function assertSmokeBindingState(args: {
   }
   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}. Run \`nolo agent bind-current ${args.agent?.dbKey ?? "AGENT_KEY"}\` first or pass --bind to rebind explicitly.`
+      `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.`
     );
   }
 }
@@ -213,16 +230,72 @@ 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 agentKey = args[0]?.trim();
-  if (!agentKey || agentKey === "--help" || agentKey === "-h") {
+  const agentInput = args[0]?.trim();
+  if (!agentInput || agentInput === "--help" || agentInput === "-h") {
     output.write("Usage: nolo agent bind-current <agentKey>\n");
-    return agentKey ? 0 : 1;
+    return agentInput ? 0 : 1;
   }
 
   const authToken = resolveAuthToken(args, env);
@@ -240,11 +313,25 @@ export async function runAgentBindCurrentCommand(
   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;
   const machine = await (deps.machineInfo ?? detectLaunchableMachineInfo)();
 
   try {
     await heartbeatCurrentMachine({ authToken, fetchImpl, machine, serverUrl });
-    const existing = await readAgentRecord({ agentKey, authToken, fallbackFetchImpl, fetchImpl, serverUrl });
+    const existing =
+      resolvedAgent.source === "remote-cache"
+        ? resolvedAgent.record
+        : await readAgentRecord({ agentKey, authToken, fallbackFetchImpl, fetchImpl, serverUrl });
     const updated = {
       ...existing,
       runtimeBinding: {
@@ -290,7 +377,6 @@ export async function runAgentSmokeCurrentCommand(
     output.write("Usage: nolo agent smoke-current <agent> [--msg \"hello\"] [--bind]\n");
     return agentInput ? 0 : 1;
   }
-  const agentKey = resolveCliAgentKeyInput(agentInput);
 
   const authToken = resolveAuthToken(args, env);
   if (!authToken) {
@@ -307,12 +393,29 @@ export async function runAgentSmokeCurrentCommand(
   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;
   const machine = await (deps.machineInfo ?? detectLaunchableMachineInfo)();
   const sentMessages: string[] = [];
 
   try {
     await heartbeatCurrentMachine({ authToken, fetchImpl, machine, serverUrl });
-    const existing = await readAgentRecord({ agentKey, authToken, fallbackFetchImpl, fetchImpl, serverUrl });
+    const existing = await readResolvedAgentRecord({
+      authToken,
+      fallbackFetchImpl,
+      fetchImpl,
+      resolvedAgent,
+      serverUrl,
+    });
     assertSmokeCompatible(existing, machine);
     assertSmokeBindingState({
       agent: existing,
@@ -367,7 +470,8 @@ export async function runAgentSmokeCurrentCommand(
             AUTH_TOKEN: authToken,
             NOLO_MACHINE_API_KEY: authToken,
           },
-          fetchImpl
+          fetchImpl,
+          deps.connectorRunDispatchDeps,
         ),
         onOpen: async () => {
           const res = await fetchImpl(`${serverUrl}/api/agent/run`, {
@@ -402,6 +506,106 @@ 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 = {}
@@ -413,27 +617,45 @@ 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);
   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 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 = await readAgentRecord({ agentKey, authToken, fallbackFetchImpl, fetchImpl, serverUrl });
+    const agent =
+      resolvedAgent.source === "remote-cache"
+        ? resolvedAgent.record
+        : await readAgentRecord({ agentKey, authToken, fallbackFetchImpl, fetchImpl, serverUrl });
     const requiredCapability = requiredCapabilityForAgent(agent);
     const runtimeClass = classifyAgentRuntime(agent);
     const hasCapability = requiredCapability
       ? machine.capabilities.includes(requiredCapability)
       : false;
-    const bindingFacts = runtimeBindingFacts(agent, machine, parseUserIdFromAuthToken(authToken));
+    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`);

package/agentPullCommand.ts

@@ -1,8 +1,13 @@
 import { getDefaultCliLocalRuntimeDb } from "./localRuntimeDb";
 import type { CliLocalRuntimeDb } from "./client/localRuntimeAdapter";
 import type { OutputLike } from "./cliIoTypes";
-import { resolveCliAgentKeyInput } from "./agentAliases";
 import {
+  buildCurrentUserPlatformAgentCandidateKeys,
+  resolveCliAgentKeyInput,
+} from "./agentAliases";
+import { resolveAgentRecordFromHybridStore } from "./agentRecordHelpers";
+import {
+  parseUserIdFromAuthToken,
   readCliOptionValue,
   resolveAuthToken,
   resolveServerUrl,
@@ -107,33 +112,56 @@ export async function runAgentPullCommand(args: string[], deps: AgentPullCommand
 
   const serverUrl = resolveServerUrl(args, env);
   const authToken = resolveAuthToken(args, env);
+  const currentUserId = parseUserIdFromAuthToken(authToken);
   const fetchImpl = deps.fetchImpl ?? fetch;
   const db = deps.db ?? await getDefaultCliLocalRuntimeDb();
+  const agentInput = readFlagValue(args, "--agent") ?? positionalArgs(args)[0] ?? parsed.agentKey;
+  let agentKey = parsed.agentKey;
+  let resolvedRecord: any;
 
-  let record: any;
-  try {
-    record = await readRemoteAgent({
-      agentKey: parsed.agentKey,
-      serverUrl,
-      authToken,
+  const candidateKeys = buildCurrentUserPlatformAgentCandidateKeys(agentInput, currentUserId);
+  if (candidateKeys.length > 0 && candidateKeys[0] !== parsed.agentKey) {
+    const resolved = await resolveAgentRecordFromHybridStore({
+      agentInput,
+      cliArgs: args,
+      env,
+      db,
       fetchImpl,
     });
-  } catch (error) {
-    output.write(
-      `[nolo] Failed to pull ${parsed.agentKey} from ${serverUrl}: ${
-        error instanceof Error ? error.message : String(error)
-      }\n`
-    );
-    return 1;
+    if (resolved?.agentKey) {
+      agentKey = resolved.agentKey;
+      if (resolved.source === "remote-cache") {
+        resolvedRecord = resolved.record;
+      }
+    }
+  }
+
+  let record: any = resolvedRecord;
+  if (!record) {
+    try {
+      record = await readRemoteAgent({
+        agentKey,
+        serverUrl,
+        authToken,
+        fetchImpl,
+      });
+    } catch (error) {
+      output.write(
+        `[nolo] Failed to pull ${agentKey} from ${serverUrl}: ${
+          error instanceof Error ? error.message : String(error)
+        }\n`
+      );
+      return 1;
+    }
   }
 
   if (!record || typeof record !== "object") {
-    output.write(`[nolo] Server returned an empty agent record for ${parsed.agentKey}.\n`);
+    output.write(`[nolo] Server returned an empty agent record for ${agentKey}.\n`);
     return 1;
   }
 
-  const localRecord = normalizeAgentRecord(parsed.agentKey, record);
-  await db.put(parsed.agentKey, localRecord);
-  output.write(`[nolo] cached ${parsed.agentKey} in local LevelDB\n`);
+  const localRecord = normalizeAgentRecord(agentKey, record);
+  await db.put(agentKey, localRecord);
+  output.write(`[nolo] cached ${agentKey} in local LevelDB\n`);
   return 0;
 }