nolo-cli 0.1.30 → 0.1.32

package/agentRecordHelpers.ts

@@ -1,8 +1,14 @@
 import { readFileSync } from "node:fs";
-import { resolveCliAgentKeyInput } from "./agentAliases";
+import {
+  buildPrivateAgentKey,
+  buildCurrentUserPlatformAgentCandidateKeys,
+  resolveCliAgentKeyInput,
+  resolvePlatformAgentAliasSpec,
+} from "./agentAliases";
 import type { CliKvDb } from "./client/hybridRecordStore";
 import { buildLocalAgentLookupKeys, shouldReadAgentKeyRemotely } from "./client/localAgentRecords";
 import {
+  hasExplicitServerOverride,
   parseUserIdFromAuthToken,
   readOption,
   resolveAuthToken,
@@ -10,6 +16,7 @@ import {
   resolveServerUrl,
   type EnvLike,
 } from "./cliEnvHelpers";
+import { parseSpaceIdFromInput, readSpaceRecordWithFallback } from "./spaceMutationHelpers";
 
 const PROVIDER_COPY_FIELDS = [
   "apiSource",
@@ -270,27 +277,101 @@ export async function resolveAgentRecordFromHybridStore(args: {
 }) {
   const agentKey = resolveCliAgentKeyInput(args.agentInput);
   const authToken = resolveAuthToken(args.cliArgs ?? [], args.env);
-  const defaultServerUrl = resolveServerUrl(args.cliArgs ?? [], args.env);
+  const currentUserId = parseUserIdFromAuthToken(authToken);
+  const cliArgs = args.cliArgs ?? [];
+  const defaultServerUrl = resolveServerUrl(cliArgs, args.env);
+  const serverCandidates = resolveServerCandidates(cliArgs, args.env, defaultServerUrl);
+  const preferRemote = hasExplicitServerOverride(cliArgs);
+  const aliasSpec = resolvePlatformAgentAliasSpec(args.agentInput);
+  const rawSpaceInput = readOption(cliArgs, "--space");
+  const preferredLookupKeys = buildCurrentUserPlatformAgentCandidateKeys(
+    args.agentInput,
+    currentUserId
+  );
+  const collectSpaceAttachedCandidateKeys = (spaceRecord: any) => {
+    const contents = spaceRecord?.contents;
+    if (!contents || typeof contents !== "object") return [];
+
+    const currentUserPrivateKey =
+      currentUserId ? buildPrivateAgentKey(currentUserId, aliasSpec!.agentId) : null;
+    const canonicalMatches: string[] = [];
+    const otherMatches: string[] = [];
+    const currentUserMatches: string[] = [];
+
+    for (const [entryKey, value] of Object.entries(contents)) {
+      if (!value || typeof value !== "object") continue;
+      const contentKey =
+        typeof (value as any).contentKey === "string" && (value as any).contentKey.trim()
+          ? (value as any).contentKey.trim()
+          : entryKey.trim();
+      if (!contentKey || !contentKey.endsWith(`-${aliasSpec!.agentId}`)) continue;
+      if (contentKey === aliasSpec!.canonicalKey) {
+        canonicalMatches.push(contentKey);
+        continue;
+      }
+      if (currentUserPrivateKey && contentKey === currentUserPrivateKey) {
+        currentUserMatches.push(contentKey);
+        continue;
+      }
+      otherMatches.push(contentKey);
+    }
 
-  for (const key of buildLocalAgentLookupKeys({
-    agentRef: agentKey,
-    userId: parseUserIdFromAuthToken(authToken) || "local",
-  })) {
+    return Array.from(
+      new Set([
+        ...canonicalMatches.sort(),
+        ...otherMatches.sort(),
+        ...currentUserMatches.sort(),
+      ])
+    );
+  };
+  const resolveSpaceAttachedCandidateKeys = async () => {
+    if (!aliasSpec || !rawSpaceInput || !authToken) return [];
     try {
-      const record = await args.db.get(key);
-      if (record && typeof record === "object") {
-        return {
-          agentKey: key,
-          record,
-          source: record?.serverOrigin ? "remote-cache" : "local-cache",
-        } as const;
+      const spaceId = parseSpaceIdFromInput(rawSpaceInput);
+      let localSpaceRecord: any = null;
+      try {
+        localSpaceRecord = await args.db.get(`space-${spaceId}`);
+      } catch {
+        localSpaceRecord = null;
       }
+
+      const localMatches = collectSpaceAttachedCandidateKeys(localSpaceRecord);
+      if (localMatches.length > 0) return localMatches;
+
+      const spaceRecord = await readSpaceRecordWithFallback({
+        authToken,
+        db: {
+          ...args.db,
+          get: async () => {
+            throw new Error("force remote refresh for shared space alias resolution");
+          },
+        },
+        fallbackFetchImpl: args.fallbackFetchImpl,
+        fetchImpl: args.fetchImpl,
+        serverCandidates,
+        spaceId,
+      });
+      if (spaceRecord && typeof args.db.put === "function") {
+        await args.db.put(`space-${spaceId}`, spaceRecord);
+      }
+      return collectSpaceAttachedCandidateKeys(spaceRecord);
     } catch {
-      // local miss
+      return [];
     }
+  };
+  const spaceAttachedLookupKeys = await resolveSpaceAttachedCandidateKeys();
+  const lookupKeys =
+    spaceAttachedLookupKeys.length > 0
+      ? Array.from(new Set([...spaceAttachedLookupKeys, ...preferredLookupKeys]))
+      : preferredLookupKeys.length > 0
+        ? preferredLookupKeys
+      : buildLocalAgentLookupKeys({
+          agentRef: agentKey,
+          userId: currentUserId || "local",
+        });
 
-    if (!shouldReadAgentKeyRemotely(key)) continue;
-    for (const serverUrl of resolveServerCandidates(args.cliArgs ?? [], args.env, defaultServerUrl)) {
+  const readRemoteRecord = async (key: string) => {
+    for (const serverUrl of serverCandidates) {
       try {
         const remoteRecord = await readAgentRecord({
           agentKey: key,
@@ -310,6 +391,31 @@ export async function resolveAgentRecordFromHybridStore(args: {
         // try next
       }
     }
+    return null;
+  };
+
+  for (const key of lookupKeys) {
+    if (preferRemote && shouldReadAgentKeyRemotely(key)) {
+      const remoteFirst = await readRemoteRecord(key);
+      if (remoteFirst) return remoteFirst;
+    }
+
+    try {
+      const record = await args.db.get(key);
+      if (record && typeof record === "object") {
+        return {
+          agentKey: key,
+          record,
+          source: record?.serverOrigin ? "remote-cache" : "local-cache",
+        } as const;
+      }
+    } catch {
+      // local miss
+    }
+
+    if (!shouldReadAgentKeyRemotely(key)) continue;
+    const remoteFallback = await readRemoteRecord(key);
+    if (remoteFallback) return remoteFallback;
   }
 
   return null;

package/agentRunCommand.ts

@@ -1,5 +1,6 @@
 import { runAgentTurn, type RunAgentTurnResult } from "./client/agentRun";
 import type { AgentRuntimeHostAdapter } from "./agentRuntimeLocal";
+import { getReadableCliDb, type AgentCommandDeps } from "./agentCommandSupport";
 import {
   prepareTaskWorktree,
   ensureWorkspacePackageLinks,
@@ -14,14 +15,19 @@ import {
 import {
   normalizeCliImageInput,
   parseAgentRunArgs,
+  readAgentRunInput,
   prependWorkflowReferencePrompt,
   resolveWorkflowReference,
   type ParsedAgentRunArgs,
   type ResolvedWorkflowReference,
 } from "./agentRunParsing";
-import { resolveServerUrl } from "./cliEnvHelpers";
+import { resolveAgentRecordFromHybridStore } from "./agentRecordHelpers";
+import {
+  buildCurrentUserPlatformAgentCandidateKeys,
+} from "./agentAliases";
+import { parseUserIdFromAuthToken, resolveAuthToken, resolveServerUrl } from "./cliEnvHelpers";
 
-type AgentRunCommandDeps = {
+type AgentRunCommandDeps = AgentCommandDeps & {
   env?: EnvLike;
   scriptDir: string;
   output?: OutputLike;
@@ -56,6 +62,41 @@ function writeUsage(output: OutputLike) {
   );
 }
 
+async function maybeResolveCurrentUserPlatformAgentKey(args: {
+  cliArgs: string[];
+  deps: AgentRunCommandDeps;
+  env: EnvLike;
+  output: OutputLike;
+  parsed: ParsedAgentRunArgs;
+}) {
+  const agentInput = readAgentRunInput(args.cliArgs);
+  if (!agentInput) return args.parsed;
+
+  const authToken = resolveAuthToken(args.cliArgs, args.env);
+  const currentUserId = parseUserIdFromAuthToken(authToken);
+  if (!currentUserId) return args.parsed;
+
+  const candidateKeys = buildCurrentUserPlatformAgentCandidateKeys(agentInput, currentUserId);
+  if (candidateKeys.length === 0 || candidateKeys[0] === args.parsed.agentKey) {
+    return args.parsed;
+  }
+
+  try {
+    const db = args.deps.db ?? await getReadableCliDb(args.output);
+    const resolved = await resolveAgentRecordFromHybridStore({
+      agentInput,
+      cliArgs: args.cliArgs,
+      env: args.env,
+      db,
+      fetchImpl: args.deps.fetchImpl ?? fetch,
+      fallbackFetchImpl: args.deps.fallbackFetchImpl,
+    });
+    return resolved ? { ...args.parsed, agentKey: resolved.agentKey } : args.parsed;
+  } catch {
+    return args.parsed;
+  }
+}
+
 export async function runAgentRunCommand(args: string[], deps: AgentRunCommandDeps) {
   const env = deps.env ?? process.env;
   const output = deps.output ?? process.stdout;
@@ -64,13 +105,20 @@ export async function runAgentRunCommand(args: string[], deps: AgentRunCommandDe
     writeUsage(output);
     return 1;
   }
+  const resolvedParsed = await maybeResolveCurrentUserPlatformAgentKey({
+    cliArgs: args,
+    deps,
+    env,
+    output,
+    parsed,
+  });
 
   const runner = deps.runner ?? runAgentTurn;
   let workflowReference: ResolvedWorkflowReference | undefined;
-  if (parsed.workflowRef) {
+  if (resolvedParsed.workflowRef) {
     try {
       workflowReference = await (deps.resolveWorkflowReference ?? resolveWorkflowReference)(
-        parsed.workflowRef
+        resolvedParsed.workflowRef
       );
     } catch (error) {
       output.write(`[nolo] ${error instanceof Error ? error.message : String(error)}\n`);
@@ -78,7 +126,7 @@ export async function runAgentRunCommand(args: string[], deps: AgentRunCommandDe
     }
   }
   const localWorkspace = await prepareLocalRunWorkspace({
-    parsed,
+    parsed: resolvedParsed,
     env,
     output,
     ...(deps.prepareTaskWorktree ? { prepareTaskWorktree: deps.prepareTaskWorktree } : {}),
@@ -89,11 +137,11 @@ export async function runAgentRunCommand(args: string[], deps: AgentRunCommandDe
   if (!localWorkspace.ok) return localWorkspace.exitCode;
   const { localRuntimeCwd, runEnv } = localWorkspace;
   const result: RunAgentTurnResult = await runner({
-    agentName: parsed.agentKey,
-    agentKey: parsed.agentKey,
+    agentName: resolvedParsed.agentKey,
+    agentKey: resolvedParsed.agentKey,
     serverUrl: resolveServerUrl(args, env),
-    message: prependWorkflowReferencePrompt(parsed.message, workflowReference),
-    imageUrls: parsed.imageUrls.map(normalizeCliImageInput),
+    message: prependWorkflowReferencePrompt(resolvedParsed.message, workflowReference),
+    imageUrls: resolvedParsed.imageUrls.map(normalizeCliImageInput),
     scriptDir: deps.scriptDir,
     env: runEnv,
     output,
@@ -101,30 +149,30 @@ export async function runAgentRunCommand(args: string[], deps: AgentRunCommandDe
       ? { localRuntimeAdapterFactory: deps.localRuntimeAdapterFactory }
       : {}),
     ...(localRuntimeCwd ? { localRuntimeCwd } : {}),
-    ...(parsed.runtimeMode ? { runtimeMode: parsed.runtimeMode } : {}),
-    ...(parsed.continueDialogId ? { continueDialogId: parsed.continueDialogId } : {}),
-    ...(parsed.spaceId ? { spaceId: parsed.spaceId } : {}),
-    ...(parsed.category ? { category: parsed.category } : {}),
-    ...(parsed.inheritedFromDialogKey ? { inheritedFromDialogKey: parsed.inheritedFromDialogKey } : {}),
-    ...(parsed.parentDialogId ? { parentDialogId: parsed.parentDialogId } : {}),
-    background: parsed.background,
-    noStream: parsed.noStream,
-    noDefaultTestRoot: parsed.noDefaultTestRoot,
-    ...(typeof parsed.maxToolRounds === "number" ? { maxToolRounds: parsed.maxToolRounds } : {}),
-    ...(typeof parsed.timeoutMs === "number" ? { timeoutMs: parsed.timeoutMs } : {}),
-    traceTools: parsed.traceTools,
-    ...(parsed.taskRunContext ? { taskRunContext: parsed.taskRunContext } : {}),
+    ...(resolvedParsed.runtimeMode ? { runtimeMode: resolvedParsed.runtimeMode } : {}),
+    ...(resolvedParsed.continueDialogId ? { continueDialogId: resolvedParsed.continueDialogId } : {}),
+    ...(resolvedParsed.spaceId ? { spaceId: resolvedParsed.spaceId } : {}),
+    ...(resolvedParsed.category ? { category: resolvedParsed.category } : {}),
+    ...(resolvedParsed.inheritedFromDialogKey ? { inheritedFromDialogKey: resolvedParsed.inheritedFromDialogKey } : {}),
+    ...(resolvedParsed.parentDialogId ? { parentDialogId: resolvedParsed.parentDialogId } : {}),
+    background: resolvedParsed.background,
+    noStream: resolvedParsed.noStream,
+    noDefaultTestRoot: resolvedParsed.noDefaultTestRoot,
+    ...(typeof resolvedParsed.maxToolRounds === "number" ? { maxToolRounds: resolvedParsed.maxToolRounds } : {}),
+    ...(typeof resolvedParsed.timeoutMs === "number" ? { timeoutMs: resolvedParsed.timeoutMs } : {}),
+    traceTools: resolvedParsed.traceTools,
+    ...(resolvedParsed.taskRunContext ? { taskRunContext: resolvedParsed.taskRunContext } : {}),
   });
 
   if (result.dialogId) {
-    if (parsed.background) {
+    if (resolvedParsed.background) {
       output.write(`\n[nolo] background dialog ${result.dialogId}\n`);
       output.write(`[nolo] read: nolo dialog read ${result.dialogId}\n`);
     } else {
       output.write(`\n[nolo] dialog ${result.dialogId}\n`);
     }
   }
-  if (shouldPrintLocalRunSummary({ parsed, localRuntimeCwd })) {
+  if (shouldPrintLocalRunSummary({ parsed: resolvedParsed, localRuntimeCwd })) {
     try {
       const inspect = deps.inspectLocalRunWorkspace ?? inspectLocalRunWorkspace;
       const inspection = await inspect(localRuntimeCwd!);

package/agentRunParsing.ts

@@ -1,6 +1,10 @@
 import { existsSync, readFileSync } from "node:fs";
 import { extname, resolve } from "node:path";
 
+import {
+  buildAgentRunDialogLineageFields,
+  normalizeAgentRunDialogLineage,
+} from "./ai/agent/agentRunDialogLineage";
 import { parseSkillDocProtocol, type WorkflowReferenceConfig } from "./ai/skills/skillDocProtocol";
 
 import { resolveCliAgentKeyInput } from "./agentAliases";
@@ -50,6 +54,12 @@ function readFlagValue(args: string[], flag: string) {
   return args[index + 1];
 }
 
+export function readAgentRunInput(args: string[]) {
+  const rawInput = readFlagValue(args, "--agent") ?? positionalArgs(args)[0];
+  const trimmed = rawInput?.trim();
+  return trimmed ? trimmed : undefined;
+}
+
 function readRepeatedFlagValues(args: string[], flag: string) {
   const values: string[] = [];
   for (let index = 0; index < args.length; index += 1) {
@@ -168,7 +178,10 @@ export function parseAgentRunArgs(
   if (!agentKey || !rawMessage.trim()) return null;
   const message = rawMessage.trim();
   const runtimeMode = runtimeModeFromArgs(args);
-  const continueDialogId = readFlagValue(args, "--continue") ?? readFlagValue(args, "--dialog");
+  const rawContinueDialogId = readFlagValue(args, "--continue") ?? readFlagValue(args, "--dialog");
+  const continueDialogId = normalizeAgentRunDialogLineage({
+    continueDialogId: rawContinueDialogId,
+  }).continueDialogId;
   const spaceId = readFlagValue(args, "--space");
   const category = readFlagValue(args, "--category");
   const inheritedFromDialog = readFlagValue(args, "--inherit-from-dialog");
@@ -219,11 +232,17 @@ export function parseAgentRunArgs(
     background: args.includes("--bg"),
     noStream: args.includes("--no-stream"),
     noDefaultTestRoot,
-    ...(continueDialogId ? { continueDialogId } : {}),
+    ...buildAgentRunDialogLineageFields({
+      continueDialogId,
+      inheritedFromDialogKey: inheritedRef?.dialogKey,
+      parentDialogId: inheritedRef?.dialogId,
+    }),
     ...(!continueDialogId && spaceId ? { spaceId } : {}),
-    ...(category ? { category } : !continueDialogId && !noDefaultTestRoot ? { category: DEFAULT_TEST_DIALOG_CATEGORY_ID } : {}),
-    ...(inheritedRef?.dialogKey ? { inheritedFromDialogKey: inheritedRef.dialogKey } : {}),
-    ...(inheritedRef?.dialogId ? { parentDialogId: inheritedRef.dialogId } : {}),
+    ...(category
+      ? { category }
+      : !continueDialogId && !noDefaultTestRoot
+        ? { category: DEFAULT_TEST_DIALOG_CATEGORY_ID }
+        : {}),
     ...(cwd ? { cwd } : {}),
     ...(typeof maxToolRounds === "number" ? { maxToolRounds } : {}),
     ...(typeof timeoutMs === "number" ? { timeoutMs } : {}),

package/agentRuntimeLocal.ts

@@ -1,7 +1,9 @@
 export {
+  createHostRuntimeConfig,
   buildOpenAiCompatibleChatCompletionRequest,
   buildPlatformChatCompletionRequest,
   canUsePlatformChatProvider,
+  createHostRuntimeCapabilities,
   hasDirectOpenAiCompatibleProvider,
   createHybridRecordStore,
   executeLocalToolWithPolicy,
@@ -16,9 +18,12 @@ export {
   parsePlatformChatCompletionData,
   parsePlatformChatCompletionResponse,
   resolveAgentRuntimeConfigFromRecord,
+  resolveHostRuntimeConfigFromEnv,
+  resolveHostRuntimeCapabilitiesFromEnv,
   resolvePlatformChatProviderConfig,
   resolveLocalToolPolicy,
   resolveOpenAiCompatibleProviderConfig,
+  resolveRequestedRuntimeToolNames,
   shouldUsePlatformChatProvider,
   shouldCacheHybridRemoteRecord,
   shouldFetchAgentRuntimeRecordRemotely,
@@ -27,6 +32,7 @@ export { runLocalAgentTurn } from "./agent-runtime/localLoop";
 export {
   buildLocalWorkspaceOpenAiTools,
   buildLocalWorkspacePolicyToolNames,
+  resolveLocalWorkspaceShellToolExposure,
   buildLocalWorkspaceToolset,
   createLocalWorkspaceToolExecutors,
 } from "./agent-runtime/localWorkspaceTools";
@@ -35,6 +41,10 @@ export type {
   AgentRuntimeHostAdapter,
   AgentRuntimeRequestedMode,
   AgentRuntimeSaveTurnInput,
+  HostRuntimeConfig,
+  HostRuntimeCapabilities,
+  HostRuntimeSurface,
+  HostRuntimeWorkspaceBinding,
   HybridRecordKvDb,
   HybridRecordStore,
   LocalToolPolicyDecision,

package/ai/agent/agentRunDialogLineage.ts

@@ -0,0 +1,56 @@
+export type AgentRunDialogLineageInput = {
+  continueDialogId?: string | null;
+  inheritedFromDialogKey?: string | null;
+  parentDialogId?: string | null;
+};
+
+export type NormalizedAgentRunDialogLineage = {
+  continueDialogId?: string;
+  inheritedFromDialogKey?: string;
+  parentDialogId?: string;
+  hasAuthoritativeContinueDialog: boolean;
+  hasConflictingLineage: boolean;
+};
+
+function pickOptionalString(value: unknown) {
+  if (typeof value !== "string") return undefined;
+  const normalized = value.trim();
+  return normalized.length > 0 ? normalized : undefined;
+}
+
+export function hasAuthoritativeContinueDialogId(value: unknown) {
+  return pickOptionalString(value) !== undefined;
+}
+
+export function normalizeAgentRunDialogLineage(
+  input: AgentRunDialogLineageInput
+): NormalizedAgentRunDialogLineage {
+  const continueDialogId = pickOptionalString(input.continueDialogId);
+  const inheritedFromDialogKey = pickOptionalString(input.inheritedFromDialogKey);
+  const parentDialogId = pickOptionalString(input.parentDialogId);
+  const hasAuthoritativeContinueDialog = hasAuthoritativeContinueDialogId(continueDialogId);
+
+  return {
+    continueDialogId,
+    inheritedFromDialogKey: hasAuthoritativeContinueDialog ? undefined : inheritedFromDialogKey,
+    parentDialogId: hasAuthoritativeContinueDialog ? undefined : parentDialogId,
+    hasAuthoritativeContinueDialog,
+    hasConflictingLineage:
+      hasAuthoritativeContinueDialog && Boolean(inheritedFromDialogKey || parentDialogId),
+  };
+}
+
+export function buildAgentRunDialogLineageFields(
+  input: AgentRunDialogLineageInput
+): Pick<AgentRunDialogLineageInput, "continueDialogId" | "inheritedFromDialogKey" | "parentDialogId"> {
+  const normalized = normalizeAgentRunDialogLineage(input);
+  return {
+    ...(hasAuthoritativeContinueDialogId(normalized.continueDialogId)
+      ? { continueDialogId: normalized.continueDialogId }
+      : {}),
+    ...(normalized.inheritedFromDialogKey
+      ? { inheritedFromDialogKey: normalized.inheritedFromDialogKey }
+      : {}),
+    ...(normalized.parentDialogId ? { parentDialogId: normalized.parentDialogId } : {}),
+  };
+}