nolo-cli 0.1.43 → 0.1.45

package/cli/agentNameResolver.ts

@@ -0,0 +1,164 @@
+import { getReadableCliDb, type OutputLike } from "./agentCommandSupport";
+import {
+  listLocalCachedAgents,
+  listRemoteAgentsAcrossServers,
+  type ListedAgent,
+} from "./agentListHelpers";
+import { resolveCliAgentKeyInput } from "./agentAliases";
+import {
+  parseUserIdFromAuthToken,
+  resolveAuthToken,
+  resolveServerCandidates,
+  resolveServerUrl,
+  type EnvLike,
+} from "./cliEnvHelpers";
+import type { CliKvDb } from "./client/hybridRecordStore";
+
+export type ResolvedAgentInput = {
+  agentKey: string;
+  agentName: string;
+  source: "explicit" | "agent-list";
+};
+
+function normalizeAgentName(value: string) {
+  return value.trim().toLowerCase();
+}
+
+function isExplicitAgentKey(value: string) {
+  return /^(agent|cybot)-(pub-|[^-]+-).+/i.test(value);
+}
+
+function findAgentByName(input: string, agents: ListedAgent[]) {
+  const normalized = normalizeAgentName(input);
+  return agents.filter((agent) => normalizeAgentName(agent.name) === normalized);
+}
+
+function formatAmbiguousAgentName(input: string, matches: ListedAgent[]) {
+  return [
+    `ambiguous agent name: ${input}`,
+    ...matches.map((agent) => `- ${agent.name}: ${agent.privateKey}`),
+  ].join("\n");
+}
+
+function isAmbiguousAgentNameError(error: unknown) {
+  return error instanceof Error && error.message.startsWith("ambiguous agent name:");
+}
+
+async function listLocalAgentsForResolution(args: {
+  authToken: string;
+  db?: CliKvDb;
+  output: OutputLike;
+}) {
+  const userId = parseUserIdFromAuthToken(args.authToken);
+  if (!userId) {
+    throw new Error("could not read userId from AUTH_TOKEN; run `nolo login` first.");
+  }
+  const db = args.db ?? await getReadableCliDb(args.output);
+  return listLocalCachedAgents({ db, userId });
+}
+
+async function listRemoteAgentsForResolution(args: {
+  authToken: string;
+  env: EnvLike;
+  fallbackFetchImpl?: typeof fetch;
+  fetchImpl: typeof fetch;
+}) {
+  const userId = parseUserIdFromAuthToken(args.authToken);
+  if (!userId) {
+    throw new Error("could not read userId from AUTH_TOKEN; run `nolo login` first.");
+  }
+  const serverUrl = resolveServerUrl(args.env);
+  const serverUrls = resolveServerCandidates(args.env, serverUrl);
+  return (await listRemoteAgentsAcrossServers({
+    authToken: args.authToken,
+    fallbackFetchImpl: args.fallbackFetchImpl,
+    fetchImpl: args.fetchImpl,
+    includeLegacy: false,
+    serverUrls,
+    userId,
+  })).agents;
+}
+
+function resolveUniqueAgentName(input: string, agents: ListedAgent[]) {
+  const matches = findAgentByName(input, agents);
+  if (matches.length === 1) {
+    return {
+      agentKey: matches[0].privateKey,
+      agentName: matches[0].name,
+      source: "agent-list" as const,
+    };
+  }
+  if (matches.length > 1) {
+    throw new Error(formatAmbiguousAgentName(input, matches));
+  }
+  return null;
+}
+
+export async function resolveAgentInput(args: {
+  agentInput: string;
+  authToken?: string;
+  db?: CliKvDb;
+  env: EnvLike;
+  fallbackFetchImpl?: typeof fetch;
+  fetchImpl: typeof fetch;
+  output: OutputLike;
+}): Promise<ResolvedAgentInput> {
+  const parsed = resolveCliAgentKeyInput(args.agentInput);
+  if (isExplicitAgentKey(parsed)) {
+    return {
+      agentKey: parsed,
+      agentName: args.agentInput,
+      source: "explicit",
+    };
+  }
+
+  const authToken = args.authToken ?? resolveAuthToken(args.env);
+  if (!authToken) {
+    throw new Error(
+      `agent not found: ${args.agentInput}. Run \`nolo login\` and \`nolo agent list\`, or pass an explicit agent key.`
+    );
+  }
+
+  if (args.db) {
+    try {
+      const localAgents = await listLocalAgentsForResolution({
+        authToken,
+        db: args.db,
+        output: args.output,
+      });
+      const localMatch = resolveUniqueAgentName(parsed, localAgents);
+      if (localMatch) return localMatch;
+    } catch (error) {
+      if (isAmbiguousAgentNameError(error)) throw error;
+      // Local cache is an optimization; remote agent list remains authoritative enough to resolve names.
+    }
+  }
+
+  try {
+    const remoteAgents = await listRemoteAgentsForResolution({
+      authToken,
+      env: args.env,
+      fallbackFetchImpl: args.fallbackFetchImpl,
+      fetchImpl: args.fetchImpl,
+    });
+    const remoteMatch = resolveUniqueAgentName(parsed, remoteAgents);
+    if (remoteMatch) return remoteMatch;
+  } catch (error) {
+    if (isAmbiguousAgentNameError(error)) throw error;
+    if (!args.db) {
+      try {
+        const localAgents = await listLocalAgentsForResolution({
+          authToken,
+          output: args.output,
+        });
+        const localMatch = resolveUniqueAgentName(parsed, localAgents);
+        if (localMatch) return localMatch;
+      } catch (localError) {
+        if (isAmbiguousAgentNameError(localError)) throw localError;
+        // Fall through to the user-facing not-found message below.
+      }
+    }
+  }
+
+  throw new Error(`agent not found by name: ${args.agentInput}. Run \`nolo agent list\` to see available agents.`);
+}

package/cli/agentRecordCommands.ts

@@ -1,4 +1,3 @@
-import { resolveCliAgentKeyInput } from "./agentAliases";
 import { getReadableCliDb, type AgentCommandDeps } from "./agentCommandSupport";
 import {
   buildUpdatedAgentRecord,
@@ -28,7 +27,6 @@ export async function runAgentReadCommand(
     return 1;
   }
 
-  const agentKey = resolveCliAgentKeyInput(agentInput);
   const db = deps.db ?? await getReadableCliDb(output);
   const fetchImpl = deps.fetchImpl ?? fetch;
   const fallbackFetchImpl = deps.fallbackFetchImpl;
@@ -43,7 +41,7 @@ export async function runAgentReadCommand(
       fallbackFetchImpl,
     });
     if (!result) {
-      throw new Error(`agent not found: ${agentKey}`);
+      throw new Error(`agent not found: ${agentInput}`);
     }
     output.write(JSON.stringify({
       ...normalizeAgentRecordForOutput(result.agentKey, authToken, result.record),

package/cli/agentRecordHelpers.ts

@@ -2,6 +2,7 @@ import { readFileSync } from "node:fs";
 import { DataType } from "../create/types";
 import { createAgentKey } from "../database/keys";
 import { resolveCliAgentKeyInput } from "./agentAliases";
+import { resolveAgentInput } from "./agentNameResolver";
 import type { CliKvDb } from "./client/hybridRecordStore";
 import { buildLocalAgentLookupKeys, shouldReadAgentKeyRemotely } from "./client/localAgentRecords";
 import {
@@ -25,6 +26,8 @@ const PROVIDER_COPY_FIELDS = [
   "outputPrice",
 ] as const;
 
+const silentOutput = { write() {} };
+
 function readRepeatedOption(args: string[], flag: string) {
   const values: string[] = [];
   for (let index = 0; index < args.length; index += 1) {
@@ -283,10 +286,25 @@ export async function resolveAgentRecordFromHybridStore(args: {
   fetchImpl: typeof fetch;
   fallbackFetchImpl?: typeof fetch;
 }) {
-  const agentKey = resolveCliAgentKeyInput(args.agentInput);
   const authToken = args.cliArgs
     ? resolveAuthToken(args.cliArgs, args.env)
     : resolveAuthToken(args.env);
+  const resolvedAgent = await resolveAgentInput({
+    agentInput: args.agentInput,
+    authToken,
+    db: args.db,
+    env: args.env,
+    fallbackFetchImpl: args.fallbackFetchImpl,
+    fetchImpl: args.fetchImpl,
+    output: silentOutput,
+  }).catch((error) => {
+    if (error instanceof Error && error.message.startsWith("ambiguous agent name:")) {
+      throw error;
+    }
+    return null;
+  });
+  if (!resolvedAgent) return null;
+  const agentKey = resolvedAgent.agentKey;
   const defaultServerUrl = args.cliArgs
     ? resolveServerUrl(args.cliArgs, args.env)
     : resolveServerUrl(args.env);
@@ -505,7 +523,10 @@ export async function buildUpdatedAgentRecord(args: {
     fetchImpl: args.fetchImpl,
     fallbackFetchImpl: args.fallbackFetchImpl,
   });
-  const agentKey = cached?.agentKey ?? resolveCliAgentKeyInput(args.parsed.agentInput);
+  if (!cached) {
+    throw new Error(`agent not found: ${args.parsed.agentInput}`);
+  }
+  const agentKey = cached.agentKey;
   const explicitServerUrl = args.cliArgs
     ? readOption(args.cliArgs, "--server-url") || readOption(args.cliArgs, "--server")
     : undefined;

package/cli/agentRunCommand.ts

@@ -4,7 +4,9 @@ import type { AgentRuntimeHostAdapter, AgentRuntimeRequestedMode } from "./agent
 import { existsSync, readFileSync } from "node:fs";
 import { extname, resolve } from "node:path";
 import { parseSkillDocProtocol, type WorkflowReferenceConfig } from "../ai/skills/skillDocProtocol";
-import { LOCAL_CODEX_AGENT_KEY, MIMO_MONTH_AGENT_KEY, isLocalCliAgentKey, resolveCliAgentKeyInput } from "./agentAliases";
+import { LOCAL_CODEX_AGENT_KEY, isLocalCliAgentKey, resolveCliAgentKeyInput } from "./agentAliases";
+import { resolveAgentInput } from "./agentNameResolver";
+import type { CliKvDb } from "./client/hybridRecordStore";
 
 type EnvLike = Record<string, string | undefined>;
 
@@ -21,6 +23,9 @@ type AgentRunCommandDeps = {
   localRuntimeAdapterFactory?: (env: EnvLike, options?: { cwd?: string }) => AgentRuntimeHostAdapter;
   inspectLocalRunWorkspace?: typeof inspectLocalRunWorkspace;
   resolveWorkflowReference?: typeof resolveWorkflowReference;
+  db?: CliKvDb;
+  fetchImpl?: typeof fetch;
+  fallbackFetchImpl?: typeof fetch;
 };
 
 type LocalRunWorkspaceInspection = {
@@ -93,18 +98,9 @@ function runtimeModeFromArgs(args: string[]): AgentRuntimeRequestedMode | undefi
 }
 
 function isMonthlyMimoAgentRef(raw: string | undefined, resolved: string) {
-  const normalized = raw?.trim().toLowerCase();
-  return (
-    resolved === MIMO_MONTH_AGENT_KEY ||
-    normalized === "fullstack" ||
-    normalized === "full-stack" ||
-    normalized === "nolo-fullstack" ||
-    normalized === "包月mimo" ||
-    normalized === "包月mimo2.5" ||
-    normalized === "mimo-month" ||
-    normalized === "全栈" ||
-    normalized === "nolo 全栈工程师"
-  );
+  void raw;
+  void resolved;
+  return false;
 }
 
 function parsePositiveInteger(value: string | undefined) {
@@ -473,6 +469,22 @@ export async function runAgentRunCommand(args: string[], deps: AgentRunCommandDe
   }
 
   const runner = deps.runner ?? runAgentTurn;
+  let runnerAgentName = parsed.agentKey;
+  try {
+    const resolvedAgent = await resolveAgentInput({
+      agentInput: parsed.agentKey,
+      env,
+      db: deps.db,
+      fetchImpl: deps.fetchImpl ?? fetch,
+      fallbackFetchImpl: deps.fallbackFetchImpl,
+      output,
+    });
+    parsed.agentKey = resolvedAgent.agentKey;
+    runnerAgentName = resolvedAgent.agentName;
+  } catch (error) {
+    output.write(`[nolo] ${error instanceof Error ? error.message : String(error)}\n`);
+    return 1;
+  }
   let workflowReference: ResolvedWorkflowReference | undefined;
   if (parsed.workflowRef) {
     try {
@@ -493,7 +505,7 @@ export async function runAgentRunCommand(args: string[], deps: AgentRunCommandDe
     allowShell: parsed.allowShell,
   });
   const result: RunAgentTurnResult = await runner({
-    agentName: parsed.agentKey,
+    agentName: runnerAgentName,
     agentKey: parsed.agentKey,
     serverUrl: resolveServerUrl(env),
     message: prependWorkflowReferencePrompt(

package/cli/client/agentRun.ts

@@ -1,10 +1,5 @@
 import { runLocalAgentTurn } from "../agentRuntimeLocal";
 import { LOCAL_AGENT_CONFIG_MISSING_CODE } from "../../agent-runtime/localLoop";
-import {
-  MIMO_MONTH_AGENT_KEY,
-  NOLO_PROJECT_MANAGER_AGENT_KEY,
-  WIN_CODEX_AGENT_KEY,
-} from "../agentAliases";
 import type { LocalAgentToolEvent } from "../../agent-runtime/localLoop";
 import type { AgentRuntimeHostAdapter, AgentRuntimeRequestedMode } from "../agentRuntimeLocal";
 import { createCliLocalRuntimeAdapter, isBuiltinNoloAgentRef } from "./localRuntimeAdapter";
@@ -115,36 +110,6 @@ const SERVER_PLATFORM_TOOL_NAMES = new Set([
   "updateTableRows",
 ]);
 
-const KNOWN_SERVER_PLATFORM_AGENT_KEYS = new Set([
-  MIMO_MONTH_AGENT_KEY,
-  NOLO_PROJECT_MANAGER_AGENT_KEY,
-  WIN_CODEX_AGENT_KEY,
-]);
-
-const KNOWN_SERVER_PLATFORM_AGENT_ALIASES = new Set([
-  "code-review",
-  "frontend",
-  "frontend-agent",
-  "frontend-implementer",
-  "full-stack",
-  "fullstack",
-  "nolo code review",
-  "nolo frontend",
-  "nolo fullstack",
-  "nolo project manager",
-  "nolo reviewer",
-  "nolo-code-review",
-  "nolo-frontend",
-  "nolo-fullstack",
-  "nolo-pm",
-  "nolo-project-manager",
-  "nolo-reviewer",
-  "pm",
-  "project-manager",
-  "review",
-  "reviewer",
-]);
-
 export function findServerPlatformTools(toolNames?: string[]) {
   if (!Array.isArray(toolNames)) return [];
   return toolNames.filter((toolName) => SERVER_PLATFORM_TOOL_NAMES.has(toolName));
@@ -159,16 +124,6 @@ function resolveServerPlatformToolNames(agentConfig: any) {
   ]);
 }
 
-function normalizeAgentRef(ref?: string) {
-  return ref?.trim().toLowerCase().replace(/\s+/g, " ");
-}
-
-function isKnownServerPlatformAgent(options: RunAgentTurnOptions) {
-  if (KNOWN_SERVER_PLATFORM_AGENT_KEYS.has(options.agentKey)) return true;
-  const normalizedKey = normalizeAgentRef(options.agentKey);
-  return Boolean(normalizedKey && KNOWN_SERVER_PLATFORM_AGENT_ALIASES.has(normalizedKey));
-}
-
 function isMachineBoundLocalhostCustomProvider(agentConfig: any) {
   const machineId =
     agentConfig?.runtimeBinding && typeof agentConfig.runtimeBinding === "object"
@@ -233,30 +188,15 @@ async function shouldSkipAutoLocalForServerPlatformTools(options: RunAgentTurnOp
   if (options.localRuntimeCwd) {
     return false;
   }
-  const knownServerPlatformAgent = isKnownServerPlatformAgent(options);
   const adapter = resolveLocalRuntimeAdapter(options);
-  if (!adapter) return knownServerPlatformAgent;
+  if (!adapter) return false;
   let agentConfig;
   try {
     agentConfig = await adapter.loadAgentConfig(options.agentKey);
   } catch {
-    if (knownServerPlatformAgent) {
-      options.output.write(
-        `[nolo] auto runtime: skipping local runtime because ${options.agentKey} is a known platform agent. ` +
-          "Use --local explicitly to force local workspace tools.\n"
-      );
-      return true;
-    }
     return false;
   }
   if (isCliProviderAgentConfig(agentConfig)) return false;
-  if (knownServerPlatformAgent) {
-    options.output.write(
-      `[nolo] auto runtime: skipping local runtime because ${options.agentKey} is a known platform agent. ` +
-        "Use --local explicitly to force local workspace tools.\n"
-    );
-    return true;
-  }
   if (isMachineBoundLocalhostCustomProvider(agentConfig)) {
     options.output.write(
       `[nolo] auto runtime: skipping local runtime because ${options.agentKey} is a machine-bound localhost custom provider. ` +

package/cli/client/localRuntimeAdapter.ts

@@ -50,7 +50,6 @@ import {
   LOCAL_CODEX_AGENT_KEY,
   LOCAL_QODER_AGENT_ID,
   LOCAL_QODER_AGENT_KEY,
-  MIMO_MONTH_AGENT_KEY,
   NOLO_DEFAULT_AGENT_ID,
   NOLO_DEFAULT_AGENT_KEY,
 } from "../agentAliases";
@@ -424,10 +423,6 @@ function summarizeOpenAiToolNames(tools: Array<Record<string, unknown>>) {
     .filter((name): name is string => Boolean(name));
 }
 
-function shouldExposeLocalPlatformTools(agentKey?: string) {
-  return agentKey !== MIMO_MONTH_AGENT_KEY;
-}
-
 function addDefaultLightWebToolsForConfiguredAgents(
   toolNames: string[],
   agentConfig?: AgentRuntimeAgentConfig | null,
@@ -449,7 +444,6 @@ function addDefaultLightWebToolsForConfiguredAgents(
 
 function buildOpenAiTools(args: { agentKey?: string; toolNames?: string[]; env: EnvLike }) {
   const toolset = buildLocalWorkspaceToolsetForEnv(args);
-  const exposePlatformTools = shouldExposeLocalPlatformTools(args.agentKey);
   return [
     ...buildLocalWorkspaceOpenAiTools({
       toolNames: toolset.toolNames,
@@ -463,8 +457,8 @@ function buildOpenAiTools(args: { agentKey?: string; toolNames?: string[]; env:
       searchFilesDescriptionVariant: resolveSearchFilesDescriptionVariant(args.env),
       searchFilesParameterVariant: resolveSearchFilesParameterVariant(args.env),
     }),
-    ...(exposePlatformTools ? buildServerPlatformOpenAiTools({ toolNames: args.toolNames }) : []),
-    ...(exposePlatformTools ? buildNoloWorkspaceOpenAiTools({ toolNames: args.toolNames }) : []),
+    ...buildServerPlatformOpenAiTools({ toolNames: args.toolNames }),
+    ...buildNoloWorkspaceOpenAiTools({ toolNames: args.toolNames }),
   ];
 }
 

package/cli/commandRegistry.ts

@@ -64,7 +64,7 @@ export function renderHelpText() {
     "  nolo agent pull agent-pub-01APPBUILDER00000001YAII3I",
   "  nolo agent read agent-pub-01APPBUILDER00000001YAII3I",
     "  nolo agent usage qoder",
-  '  nolo agent run frontend-implementer --msg "polish notifications"',
+  '  nolo agent run frontend --msg "polish notifications"',
     "  nolo agent bind-current agent-user-1-agent-1",
     "  nolo agent runtime-doctor agent-user-1-agent-1",
     '  nolo agent smoke-current agent-user-1-agent-1 --msg "ping"',
@@ -73,8 +73,8 @@ export function renderHelpText() {
     "  nolo space read 01KKY77TT0DA9NY7TNW3R7255N --content-key page-user-id --brief",
     "  nolo space delete --name-prefix rn_owner_verify_0504 --yes",
     "  nolo table query --table 01ABCXYZ",
-    '  nolo table query --table meta-0e95801d90-NOLOTASKBOARD --columns \'["title","status","owner","priority","codeStatus"]\' --no-base-fields --output items',
-    '  nolo table update-row --table meta-0e95801d90-NOLOTASKBOARD --row 01ROWID --changes \'{"status":"已完成"}\'',
+    '  nolo table query --table meta-your-user-TASKBOARD --columns \'["title","status","owner","priority","codeStatus"]\' --no-base-fields --output items',
+    '  nolo table update-row --table meta-your-user-TASKBOARD --row 01ROWID --changes \'{"status":"done"}\'',
     "  nolo llama status",
   ];
 

package/cli/machineCommands.ts

@@ -150,6 +150,9 @@ function buildTaskEvidencePrompt(args: {
 }) {
   const rowDbKey = findTaskRowSubjectRef(args.runtimeContext);
   if (!rowDbKey) return "";
+  const taskBoardTableKey = typeof args.runtimeContext?.taskBoardTableKey === "string"
+    ? args.runtimeContext.taskBoardTableKey.trim()
+    : "";
   return [
     "--- Nolo task evidence context ---",
     "This CLI runtime does not receive server-side function tools directly.",
@@ -157,7 +160,9 @@ function buildTaskEvidencePrompt(args: {
     "Run commands from the repository root. The runner already provides server URL and auth in the environment.",
     "Release boundary: after review passes, AI/reviewer/Codex may advance alpha for verification. Do not merge, push, or release main/release unless the human owner explicitly authorizes it in the current task context.",
     "Handoff context: inspect activityRefs/latestActivityRef, dialog checkpoints, artifacts, commits, and test evidence. Use dialog read/search for exact evidence; do not infer completion from handoff text alone.",
-    `Read task row: bun packages/cli/index.ts table query --table meta-0e95801d90-NOLOTASKBOARD --row ${JSON.stringify(rowDbKey)} --include-activity --output json`,
+    taskBoardTableKey
+      ? `Read task row: bun packages/cli/index.ts table query --table ${JSON.stringify(taskBoardTableKey)} --row ${JSON.stringify(rowDbKey)} --include-activity --output json`
+      : `Task row subjectRef: ${JSON.stringify(rowDbKey)}. If a task board table key is provided in context, read it with: bun packages/cli/index.ts table query --table <tableKey> --row ${JSON.stringify(rowDbKey)} --include-activity --output json`,
     "Then read linked activity dialog ids with: bun packages/cli/index.ts dialog read <dialogId>",
     "Report progress, blockers, worktree, branch, commit/diff, tests, and unverified items in the dialog.",
   ].join("\n");

package/cli/offlineMarxistsAgentCommand.ts

@@ -28,7 +28,6 @@ type ParsedArgs = {
 
 const DEFAULT_USER_ID = "b2e06f801f";
 const DEFAULT_SPACE_ID = "01KKY77TT0DA9NY7TNW3R7255N";
-const DEFAULT_SOURCE_AGENT_ID = "01MIMO25MONTH0000000NEW001";
 const DEFAULT_TARGET_AGENT_ID = "01OFFMARXBOOK000000010AHL1";
 const DEFAULT_AGENT_NAME = "离线马克思主义文库书籍转换助手";
 const TOOL_NAME = "convertMarxistsBookToOfflineHtml";
@@ -75,8 +74,8 @@ function parseArgs(args: string[], env: EnvLike): ParsedArgs | null {
     DEFAULT_USER_ID;
   const sourceAgentKey =
     readFlagValue(args, "--source-agent") ??
-    env.NOLO_MIMO_SOURCE_AGENT_KEY ??
-    `agent-${userId}-${DEFAULT_SOURCE_AGENT_ID}`;
+    env.NOLO_OFFLINE_MARXISTS_SOURCE_AGENT_KEY ??
+    "";
   const targetAgentId =
     readFlagValue(args, "--target-agent-id") ??
     env.NOLO_OFFLINE_MARXISTS_AGENT_ID ??
@@ -90,7 +89,7 @@ function parseArgs(args: string[], env: EnvLike): ParsedArgs | null {
     env.NOLO_OFFLINE_MARXISTS_SPACE_ID ??
     DEFAULT_SPACE_ID;
 
-  if (!authToken.trim()) return null;
+  if (!authToken.trim() || !sourceAgentKey.trim()) return null;
   return {
     serverUrl,
     authToken,
@@ -227,7 +226,7 @@ async function attachAgentToSpace(args: {
 function writeUsage(output: OutputLike) {
   output.write(
     "Usage: nolo agent setup-offline-marxists [--server https://nolo.chat] [--source-agent <key>] [--space <spaceId>] [--target-agent-id <id>] [--json]\n" +
-      "Requires AUTH_TOKEN from `nolo login` or --token.\n"
+      "Requires AUTH_TOKEN from `nolo login` or --token, plus --source-agent or NOLO_OFFLINE_MARXISTS_SOURCE_AGENT_KEY.\n"
   );
 }
 

package/client/agentRun.test.ts

@@ -7,7 +7,9 @@ import {
   runAgentTurn,
 } from "./agentRun";
 import { BUILTIN_NOLO_AGENT_KEY } from "./localRuntimeAdapter";
-import { MIMO_MONTH_AGENT_KEY, NOLO_PROJECT_MANAGER_AGENT_KEY } from "../agentAliases";
+
+const TEST_MONTHLY_MIMO_AGENT_KEY = "agent-user-1-monthly-mimo";
+const TEST_PROJECT_MANAGER_AGENT_KEY = "agent-user-1-project-manager";
 
 class CaptureOutput extends Writable {
   chunks: string[] = [];
@@ -929,8 +931,8 @@ describe("cli agent run client", () => {
     let providerCalled = false;
 
     const result = await runAgentTurn({
-      agentName: MIMO_MONTH_AGENT_KEY,
-      agentKey: MIMO_MONTH_AGENT_KEY,
+      agentName: TEST_MONTHLY_MIMO_AGENT_KEY,
+      agentKey: TEST_MONTHLY_MIMO_AGENT_KEY,
       serverUrl: "https://us.nolo.chat",
       message: "fix tests and commit",
       scriptDir: "C:/missing/scripts",
@@ -972,7 +974,7 @@ describe("cli agent run client", () => {
     expect(result).toEqual({ exitCode: 0, dialogId: "dialog-mimo-local" });
     expect(httpCalls).toEqual([]);
     expect(output.text()).not.toContain("skipping local runtime");
-    expect(output.text()).toContain(`${MIMO_MONTH_AGENT_KEY} -> working locally`);
+    expect(output.text()).toContain(`${TEST_MONTHLY_MIMO_AGENT_KEY} -> working locally`);
   });
 
   test("auto mode skips local runtime for machine-bound localhost custom providers", async () => {
@@ -1128,13 +1130,13 @@ describe("cli agent run client", () => {
     expect(output.text()).toContain("queryTableRows, streamParallelAgents");
   });
 
-  test("auto mode skips known platform agents when local config cannot be read", async () => {
+  test("auto mode falls back to server when local config cannot be read", async () => {
     const output = new CaptureOutput();
     const httpCalls: Array<{ url: string; body: any }> = [];
 
     const result = await runAgentTurn({
-      agentName: "nolo-project-manager",
-      agentKey: NOLO_PROJECT_MANAGER_AGENT_KEY,
+      agentName: "project-manager",
+      agentKey: TEST_PROJECT_MANAGER_AGENT_KEY,
       serverUrl: "https://us.nolo.chat",
       message: "write task rows",
       scriptDir: "C:/missing/scripts",
@@ -1168,10 +1170,10 @@ describe("cli agent run client", () => {
 
     expect(result).toEqual({ exitCode: 0, dialogId: "dialog-server" });
     expect(httpCalls).toHaveLength(1);
-    expect(httpCalls[0]?.body.agentKey).toBe(NOLO_PROJECT_MANAGER_AGENT_KEY);
-    expect(output.text()).toContain("known platform agent");
-    expect(output.text()).toContain("nolo-project-manager -> working");
-    expect(output.text()).toContain("nolo-project-manager > server ok");
+    expect(httpCalls[0]?.body.agentKey).toBe(TEST_PROJECT_MANAGER_AGENT_KEY);
+    expect(output.text()).not.toContain("known platform agent");
+    expect(output.text()).toContain("project-manager -> working");
+    expect(output.text()).toContain("project-manager > server ok");
   });
 
   test("builds the default local adapter when env requests local mode", async () => {