nolo-cli 0.1.30 → 0.1.31

package/integrations/openai/models.ts

@@ -16,38 +16,38 @@ const scalePrice = (price: ModelPrice, multiplier: number): ModelPrice => ({
 });
 
 const GPT_5_4_STANDARD_PRICE: ModelPrice = {
-  input: 2.5,
-  output: 15,
-  inputCacheHit: 0.25,
+  input: 2.5 * 8,
+  output: 15 * 8,
+  inputCacheHit: 0.25 * 8,
 };
 
 const GPT_5_5_STANDARD_PRICE: ModelPrice = {
-  input: 5,
-  output: 30,
-  inputCacheHit: 0.5,
+  input: 5 * 8,
+  output: 30 * 8,
+  inputCacheHit: 0.5 * 8,
 };
 
 const GPT_5_4_LONG_CONTEXT_PRICE: ModelPrice = {
-  input: 5,
-  output: 22.5,
-  inputCacheHit: 0.5,
+  input: 5 * 8,
+  output: 22.5 * 8,
+  inputCacheHit: 0.5 * 8,
 };
 
 const GPT_5_5_LONG_CONTEXT_PRICE: ModelPrice = {
-  input: 10,
-  output: 45,
-  inputCacheHit: 1,
+  input: 10 * 8,
+  output: 45 * 8,
+  inputCacheHit: 1 * 8,
 };
 
 const GPT_5_4_PRO_STANDARD_PRICE: ModelPrice = {
-  input: 30,
-  output: 180,
+  input: 30 * 8,
+  output: 180 * 8,
   inputCacheHit: 0,
 };
 
 const GPT_5_4_PRO_LONG_CONTEXT_PRICE: ModelPrice = {
-  input: 60,
-  output: 270,
+  input: 60 * 8,
+  output: 270 * 8,
   inputCacheHit: 0,
 };
 
@@ -141,7 +141,7 @@ export const openAIModels: Model[] = [
     // OpenAI's current public pricing page does not list GPT Image 2 separately.
     // Reuse GPT Image 1.5 pricing as a conservative placeholder until official
     // GPT Image 2 pricing is published.
-    price: { input: 5, output: 10, inputCacheHit: 1.25 },
+    price: { input: 5 * 8, output: 10 * 8, inputCacheHit: 1.25 * 8 },
     pricePerImage: 0.04 * 8,
   },
   {
@@ -190,7 +190,7 @@ export const openAIModels: Model[] = [
     contextWindow: 400_000,
     maxOutputTokens: 128_000,
     supportsReasoningEffort: true,
-    price: { input: 0.75, output: 4.5, inputCacheHit: 0.075 },
+    price: { input: 0.75 * 8, output: 4.5 * 8, inputCacheHit: 0.075 * 8 },
   },
   {
     name: "gpt-5.4-nano",
@@ -200,7 +200,7 @@ export const openAIModels: Model[] = [
     contextWindow: 400_000,
     maxOutputTokens: 128_000,
     supportsReasoningEffort: true,
-    price: { input: 0.2, output: 1.25, inputCacheHit: 0.02 },
+    price: { input: 0.2 * 8, output: 1.25 * 8, inputCacheHit: 0.02 * 8 },
   },
   {
     name: "gpt-5.4-pro",
@@ -247,7 +247,7 @@ export const openAIModels: Model[] = [
     contextWindow: 400_000,
     maxOutputTokens: 128_000,
     supportsReasoningEffort: true,
-    price: { input: 12.5, output: 100, inputCacheHit: 1.25 },
+    price: { input: 1.25 * 8, output: 10 * 8, inputCacheHit: 0.125 * 8 },
   },
   {
     name: "gpt-5-mini",
@@ -256,7 +256,7 @@ export const openAIModels: Model[] = [
     contextWindow: 400_000,
     maxOutputTokens: 128_000,
     supportsReasoningEffort: true,
-    price: { input: 2.5, output: 20, inputCacheHit: 0.25 },
+    price: { input: 0.25 * 8, output: 2 * 8, inputCacheHit: 0.025 * 8 },
   },
   {
     name: "o3-pro",
@@ -266,6 +266,6 @@ export const openAIModels: Model[] = [
     maxOutputTokens: 100_000,
     supportsReasoningEffort: true,
     endpointKey: "responses",
-    price: { input: 200, output: 800, inputCacheHit: 0 },
+    price: { input: 20 * 8, output: 80 * 8, inputCacheHit: 0 },
   },
 ];

package/integrations/xai/models.ts

@@ -6,7 +6,7 @@ export const xaiModels: Model[] = [
     displayName: "Grok4 0709",
     hasVision: false,
     contextWindow: 131072,
-    price: { input: 3 * 10, output: 15 * 10 }, // 30分 / 150分 → 0.3$ / 1.5$
+    price: { input: 3 * 8, output: 15 * 8 }, // $3/$15 per MTok × 7
     fnCall: true,
     jsonOutput: true,
   },

package/localRuntimeDb.ts

@@ -20,9 +20,46 @@ export function buildCliLocalRuntimeDbEnv(env: EnvLike = process.env) {
   };
 }
 
+export function isCliLocalRuntimeDbLockError(error: unknown): boolean {
+  const queue: unknown[] = [error];
+  const seen = new Set<unknown>();
+
+  while (queue.length > 0) {
+    const current = queue.shift();
+    if (!current || seen.has(current)) continue;
+    seen.add(current);
+
+    const text = `${(current as any)?.code ?? ""} ${(current as any)?.message ?? current}`;
+    if (/LEVEL_LOCKED|Resource temporarily unavailable|\/LOCK|LOCK:|db locked|locked/i.test(text)) {
+      return true;
+    }
+
+    if ((current as any)?.cause) queue.push((current as any).cause);
+    if (Array.isArray((current as any)?.errors)) queue.push(...(current as any).errors);
+  }
+
+  return false;
+}
+
+export function formatCliLocalRuntimeDbOpenError(dbPath: string, error: unknown) {
+  if (!isCliLocalRuntimeDbLockError(error)) {
+    return error instanceof Error ? error : new Error(String(error));
+  }
+  return new Error(
+    `CLI local runtime DB is locked at ${dbPath}. Another nolo local runtime is already using it. ` +
+      "Stop the other local runtime, rerun without --local, or set NOLO_SERVER_DB_PATH to a different cache path.",
+    { cause: error instanceof Error ? error : undefined }
+  );
+}
+
 export async function getDefaultCliLocalRuntimeDb(): Promise<CliLocalRuntimeDb> {
-  process.env.NOLO_SERVER_DB_PATH = buildCliLocalRuntimeDbEnv(process.env).NOLO_SERVER_DB_PATH;
+  const dbPath = buildCliLocalRuntimeDbEnv(process.env).NOLO_SERVER_DB_PATH;
+  process.env.NOLO_SERVER_DB_PATH = dbPath;
   const { default: serverDb, ensureServerDbOpen } = await import("./database/server/db");
-  await ensureServerDbOpen();
+  try {
+    await ensureServerDbOpen();
+  } catch (error) {
+    throw formatCliLocalRuntimeDbOpenError(dbPath, error);
+  }
   return serverDb as CliLocalRuntimeDb;
 }

package/machineCommandPrompts.ts

@@ -3,6 +3,7 @@ import {
   resolveMachineRunPermissionPolicy,
   type MachineRunPermissionPolicy,
 } from "./ai/agent/machineRunPermissions";
+import { buildNoloReadOnlyBridgePrompt } from "./noloReadBridgePrompt";
 
 export function inferTaskRunRole(agentKey: string, agentConfig: any) {
   const haystack = [agentKey, agentConfig?.name, agentConfig?.prompt]
@@ -62,6 +63,7 @@ export function buildConnectorCliPrompt(
   const policy = permissionPolicy ?? resolveMachineRunPermissionPolicy(agentConfig);
   return [
     typeof agentConfig?.prompt === "string" ? agentConfig.prompt.trim() : "",
+    buildNoloReadOnlyBridgePrompt(),
     bridgeArgs
       ? buildTaskRunBridgePrompt({
           agentKey: bridgeArgs.agentKey,

package/machineCommands.ts

@@ -1,4 +1,5 @@
 import type { MachineHeartbeat } from "./connector-experimental/protocol";
+import { NOLO_CLUSTER_SERVERS, normalizeKnownServerOrigin } from "./database/config";
 import { detectMachineInfo } from "./connector-experimental/machineInfo";
 import {
   type HeartbeatLoopOptions,
@@ -42,6 +43,7 @@ export {
 type MachineCommandDeps = {
   env?: EnvLike;
   output?: OutputLike;
+  signal?: AbortSignal;
   cliEntrypointPath?: string;
   maxConnectorAttempts?: number;
   sleep?: (ms: number) => Promise<void>;
@@ -60,6 +62,100 @@ type MachineCommandDeps = {
 };
 
 const defaultSleep = (ms: number) => new Promise<void>((resolve) => setTimeout(resolve, ms));
+const MACHINE_TOKEN_PREFIX = "sk_machine_";
+
+async function sleepWithAbort(ms: number, sleep: (ms: number) => Promise<void>, signal?: AbortSignal) {
+  if (!signal) {
+    await sleep(ms);
+    return;
+  }
+  if (signal.aborted) return;
+  await Promise.race([
+    sleep(ms),
+    new Promise<void>((resolve) => {
+      signal.addEventListener("abort", () => resolve(), { once: true });
+    }),
+  ]);
+}
+
+function resolveConnectorReconnectDelayMs(env: EnvLike) {
+  const raw = Number(env.NOLO_CONNECT_RECONNECT_MS ?? "");
+  return Number.isFinite(raw) && raw >= 0 ? raw : 5_000;
+}
+
+function isMachineToken(token: string) {
+  return token.trim().startsWith(MACHINE_TOKEN_PREFIX);
+}
+
+function resolveClusterConnectServerUrls(serverUrl: string, authToken: string) {
+  const normalizedPrimary = normalizeKnownServerOrigin(serverUrl) ?? serverUrl.trim().replace(/\/+$/, "");
+  if (isMachineToken(authToken)) return [normalizedPrimary];
+  const normalizedCluster = NOLO_CLUSTER_SERVERS
+    .map((baseUrl) => normalizeKnownServerOrigin(baseUrl) ?? baseUrl)
+    .filter((value, index, list) => value && list.indexOf(value) === index);
+  if (!normalizedCluster.includes(normalizedPrimary)) return [normalizedPrimary];
+  return [normalizedPrimary, ...normalizedCluster.filter((baseUrl) => baseUrl !== normalizedPrimary)];
+}
+
+function linkAbortSignal(signal: AbortSignal | undefined, controller: AbortController) {
+  if (!signal) return;
+  if (signal.aborted) {
+    controller.abort();
+    return;
+  }
+  signal.addEventListener("abort", () => controller.abort(), { once: true });
+}
+
+async function sendMachineHeartbeat(args: {
+  serverUrl: string;
+  authToken: string;
+  fetchImpl: typeof fetch;
+  machine: MachineHeartbeat;
+}) {
+  const res = await args.fetchImpl(`${args.serverUrl}/api/machines/heartbeat`, {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${args.authToken}`,
+      "Content-Type": "application/json",
+    },
+    body: JSON.stringify(args.machine),
+  });
+
+  if (!res.ok) {
+    const text = await res.text().catch(() => "");
+    throw new Error(`HTTP ${res.status}\n${text}`);
+  }
+}
+
+async function sendHeartbeatAcrossServers(args: {
+  serverUrls: string[];
+  authToken: string;
+  fetchImpl: typeof fetch;
+  machine: MachineHeartbeat;
+  output: OutputLike;
+}) {
+  let primaryError: Error | null = null;
+  for (const [index, serverUrl] of args.serverUrls.entries()) {
+    try {
+      await sendMachineHeartbeat({
+        serverUrl,
+        authToken: args.authToken,
+        fetchImpl: args.fetchImpl,
+        machine: args.machine,
+      });
+    } catch (error) {
+      const resolvedError = error instanceof Error ? error : new Error(String(error));
+      if (index === 0) {
+        primaryError = resolvedError;
+      } else {
+        args.output.write(
+          `[nolo] secondary connector registration failed for ${serverUrl}: ${resolvedError.message}\n`
+        );
+      }
+    }
+  }
+  if (primaryError) throw primaryError;
+}
 
 async function defaultExecuteCli(
   provider: string,
@@ -75,9 +171,9 @@ function detectLaunchableMachineInfo() {
 }
 
 export async function runMachineConnectCommand(
-  args: string[],
-  deps: MachineCommandDeps = {}
-) {
+  args: string[],
+  deps: MachineCommandDeps = {}
+) {
   const env = deps.env ?? process.env;
   const output = deps.output ?? process.stdout;
   const authToken = resolveConnectAuthToken(args, env);
@@ -85,29 +181,31 @@ export async function runMachineConnectCommand(
     writeAuthMissing(output);
     return 1;
   }
-
+
   const serverUrl = resolveConnectServerUrl(args, env);
+  const serverUrls = resolveClusterConnectServerUrls(serverUrl, authToken);
   const fetchImpl = deps.fetchImpl ?? fetch;
   const machine = (deps.machineInfo ?? detectLaunchableMachineInfo)();
   const sendHeartbeat = async () => {
-    const res = await fetchImpl(`${serverUrl}/api/machines/heartbeat`, {
-    method: "POST",
-    headers: {
-      Authorization: `Bearer ${authToken}`,
-      "Content-Type": "application/json",
-    },
-    body: JSON.stringify(machine),
-    });
-
-    if (!res.ok) {
-      const text = await res.text().catch(() => "");
-      throw new Error(`HTTP ${res.status}\n${text}`);
-    }
-  };
+    await sendHeartbeatAcrossServers({
+      serverUrls,
+      authToken,
+      fetchImpl,
+      machine,
+      output,
+    });
+  };
 
   if (hasFlag(args, "--daemon") || hasFlag(args, "--background")) {
     return runMachineDaemonCommand({
-      env,
+      env: {
+        ...env,
+        NOLO_SERVER: serverUrl,
+        NOLO_SERVER_URL: serverUrl,
+        BASE_URL: serverUrl,
+        AUTH_TOKEN: authToken,
+        NOLO_MACHINE_API_KEY: authToken,
+      },
       output,
       cliEntrypointPath: deps.cliEntrypointPath,
       validateWorkspaceLinks: deps.validateWorkspaceLinks,
@@ -123,50 +221,82 @@ export async function runMachineConnectCommand(
     const maxAttempts = deps.maxConnectorAttempts ?? Infinity;
     const sleep = deps.sleep ?? defaultSleep;
     const reconnectDelayMs = resolveConnectorReconnectDelayMs(env);
-    for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
-      const runtimeServerUrl =
-        env.NOLO_CONNECT_RUNTIME_SERVER_URL ||
-        env.NOLO_RUNTIME_SERVER_URL ||
-        serverUrl;
-      const exitCode = await runMachineWsSession({
-        env,
-        output,
-        machine,
-        sendHeartbeat,
-        runHeartbeatLoop: deps.runHeartbeatLoop ?? defaultRunHeartbeatLoop,
-        connectWebSocket: deps.connectWebSocket ?? defaultConnectWebSocket,
-        serverUrl,
-        authToken,
-        resolveConnectorWebSocketTarget: (options) =>
-          resolveConnectorWebSocketTarget({
-            ...options,
-            fetchImpl,
-          }),
-        onMessage: (message, send) =>
-          handleConnectorRunMessage(
-            message,
-            send,
-            deps.executeCli ?? defaultExecuteCli,
-            {
-              ...env,
-              NOLO_SERVER: runtimeServerUrl,
-              NOLO_SERVER_URL: runtimeServerUrl,
-              BASE_URL: runtimeServerUrl,
-              AUTH_TOKEN: authToken,
-              NOLO_MACHINE_API_KEY: authToken,
-            },
-            fetchImpl,
-            {
-              buildConnectorCliPrompt,
-            }
-          ),
-      });
-      if (exitCode === 2) return 1;
-      if (attempt >= maxAttempts) return exitCode;
-      output.write(`[nolo] Connector websocket disconnected. Reconnecting in ${reconnectDelayMs}ms.\n`);
-      await sleep(reconnectDelayMs);
-    }
-    return 0;
+    const runServerSession = async (targetServerUrl: string, signal?: AbortSignal) => {
+      for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
+        if (signal?.aborted) {
+          return { serverUrl: targetServerUrl, exitCode: 0 };
+        }
+        const runtimeServerUrl =
+          env.NOLO_CONNECT_RUNTIME_SERVER_URL ||
+          env.NOLO_RUNTIME_SERVER_URL ||
+          targetServerUrl;
+        const exitCode = await runMachineWsSession({
+          env,
+          output,
+          signal,
+          machine,
+          sendHeartbeat: () =>
+            sendMachineHeartbeat({
+              serverUrl: targetServerUrl,
+              authToken,
+              fetchImpl,
+              machine,
+            }),
+          runHeartbeatLoop: deps.runHeartbeatLoop ?? defaultRunHeartbeatLoop,
+          connectWebSocket: deps.connectWebSocket ?? defaultConnectWebSocket,
+          serverUrl: targetServerUrl,
+          authToken,
+          resolveConnectorWebSocketTarget: (options) =>
+            resolveConnectorWebSocketTarget({
+              ...options,
+              fetchImpl,
+            }),
+          onMessage: (message, send) =>
+            handleConnectorRunMessage(
+              message,
+              send,
+              deps.executeCli ?? defaultExecuteCli,
+              {
+                ...env,
+                NOLO_SERVER: runtimeServerUrl,
+                NOLO_SERVER_URL: runtimeServerUrl,
+                BASE_URL: runtimeServerUrl,
+                AUTH_TOKEN: authToken,
+                NOLO_MACHINE_API_KEY: authToken,
+              },
+              fetchImpl,
+              {
+                buildConnectorCliPrompt,
+              }
+            ),
+        });
+        if (exitCode === 2) return { serverUrl: targetServerUrl, exitCode: 2 };
+        if (signal?.aborted) {
+          return { serverUrl: targetServerUrl, exitCode: 0 };
+        }
+        if (attempt >= maxAttempts) return { serverUrl: targetServerUrl, exitCode };
+        output.write(`[nolo] Connector websocket disconnected. Reconnecting in ${reconnectDelayMs}ms.\n`);
+        await sleepWithAbort(reconnectDelayMs, sleep, signal);
+      }
+      return { serverUrl: targetServerUrl, exitCode: 0 };
+    };
+
+    const sessionAbort = new AbortController();
+    linkAbortSignal(deps.signal, sessionAbort);
+
+    const sessionPromises = serverUrls.map(async (targetServerUrl, index) => {
+      const result = await runServerSession(targetServerUrl, sessionAbort.signal);
+      if (index > 0 && result.exitCode !== 0 && !sessionAbort.signal.aborted) {
+        output.write(
+          `[nolo] secondary connector registration failed for ${targetServerUrl}: exit ${result.exitCode}\n`
+        );
+      }
+      return result;
+    });
+    const results = await Promise.all(sessionPromises);
+    if (results.some((result) => result.exitCode === 0)) return 0;
+    if (results.some((result) => result.exitCode === 2)) return 1;
+    return results[0]?.exitCode ?? 1;
   }
 
   if (hasFlag(args, "--watch")) {

package/machineWsRunDispatch.ts

@@ -1,4 +1,6 @@
 import { runLocalAgentTurn, type LocalAgentToolEvent } from "./agent-runtime/localLoop";
+import { resolveHostRuntimeConfigFromEnv } from "./agent-runtime/hostRuntimeConfig";
+import { normalizeAgentRunDialogLineage } from "./ai/agent/agentRunDialogLineage";
 import {
   assertMachineRunAllowed as defaultAssertMachineRunAllowed,
   resolveMachineRunPermissionPolicy as defaultResolveMachineRunPermissionPolicy,
@@ -118,6 +120,24 @@ function requestsLocalWorkspaceRuntime(policy?: ConnectorRuntimePolicy) {
   );
 }
 
+function isMachineBoundLocalCustomProvider(agentConfig: any) {
+  const machineId =
+    isRecord(agentConfig?.runtimeBinding) && typeof agentConfig.runtimeBinding.machineId === "string"
+      ? agentConfig.runtimeBinding.machineId.trim()
+      : "";
+  const providerUrl =
+    typeof agentConfig?.customProviderUrl === "string"
+      ? agentConfig.customProviderUrl.trim()
+      : "";
+  if (!machineId || !providerUrl) return false;
+  try {
+    const hostname = new URL(providerUrl).hostname.toLowerCase();
+    return hostname === "127.0.0.1" || hostname === "localhost" || hostname === "::1";
+  } catch {
+    return false;
+  }
+}
+
 function hasExplicitMachinePermissions(agentConfig: any) {
   const runtimeBinding = isRecord(agentConfig?.runtimeBinding) ? agentConfig.runtimeBinding : {};
   return Boolean(
@@ -130,6 +150,7 @@ function hasExplicitMachinePermissions(agentConfig: any) {
 
 function runtimeWorkspacePermissionPolicy(
   runtimePolicy: ConnectorRuntimePolicy | undefined,
+  hostRuntimeConfig: { capabilities: { allowShell: boolean } },
   cwd: string
 ): PermissionPolicy | null {
   if (!requestsTaskWorktree(runtimePolicy)) return null;
@@ -137,7 +158,10 @@ function runtimeWorkspacePermissionPolicy(
     mode: "full_access",
     allowFilesystemRead: true,
     allowFilesystemWrite: true,
-    allowShell: runtimePolicy?.shell?.enabled !== false,
+    allowShell:
+      hostRuntimeConfig.capabilities.allowShell &&
+      Array.isArray(runtimePolicy?.runtimeTools) &&
+      runtimePolicy.runtimeTools.includes("execShell"),
     writableRoots: [cwd],
   };
 }
@@ -175,13 +199,20 @@ function mergeToolNames(...values: unknown[]) {
 function localRuntimeEnvFromPolicy(runtimeEnv: EnvLike, policy?: ConnectorRuntimePolicy): EnvLike {
   return {
     ...runtimeEnv,
-    ...(policy?.shell?.enabled && policy.shell.mode === "worktree"
-      ? { NOLO_LOCAL_SHELL_MODE: "worktree" }
-      : {}),
     ...(policy?.workspace?.cwd ? { NOLO_LOCAL_WORKTREE: policy.workspace.cwd } : {}),
   };
 }
 
+function forwardedUserAuthToken(parsed: any): string {
+  const value = parsed?.payload?.meta?.userAuthToken;
+  return typeof value === "string" ? value.trim() : "";
+}
+
+function withForwardedUserAuthToken(runtimeEnv: EnvLike, parsed: any): EnvLike {
+  const userAuthToken = forwardedUserAuthToken(parsed);
+  return userAuthToken ? { ...runtimeEnv, AUTH_TOKEN: userAuthToken } : runtimeEnv;
+}
+
 function runtimeWorkspaceRootFromTrace(trace: unknown): string | undefined {
   if (!Array.isArray(trace)) return undefined;
   for (const message of trace) {
@@ -241,6 +272,12 @@ async function defaultRunConnectorLocalRuntimeAgent(args: {
     ? args.parsed.payload.agentConfig
     : {};
   const policy = runtimePolicyFromConnectorPayload(args.parsed);
+  const wantsTaskWorktree = requestsTaskWorktree(policy);
+  const hostRuntimeConfig = resolveHostRuntimeConfigFromEnv({
+    env: args.runtimeEnv,
+    surface: "connector-local",
+    workspaceBinding: wantsTaskWorktree ? "default-cwd" : "explicit-cwd",
+  });
   const agentRecord = {
     ...payloadAgentConfig,
     dbKey: agentKey,
@@ -262,12 +299,14 @@ async function defaultRunConnectorLocalRuntimeAgent(args: {
     [`agent-${args.runtimeEnv.NOLO_USER_ID || "local"}-${agentKey}`, agentRecord],
     [`agent-${args.runtimeEnv.NOLO_LOCAL_USER_ID || args.runtimeEnv.NOLO_USER_ID || "local"}-${agentKey}`, agentRecord],
   ]);
-  const env = localRuntimeEnvFromPolicy(args.runtimeEnv, policy);
-  const wantsTaskWorktree = requestsTaskWorktree(policy);
+  const env = localRuntimeEnvFromPolicy(
+    withForwardedUserAuthToken(args.runtimeEnv, args.parsed),
+    policy
+  );
   const adapter = createCliLocalRuntimeAdapter({
     env,
+    hostRuntimeConfig,
     cwd: args.cwd,
-    useCwdAsTaskWorkspaceBase: wantsTaskWorktree,
     ...(wantsTaskWorktree
       ? {
           prepareTaskWorktree: (input) => prepareTaskWorktree({
@@ -350,6 +389,20 @@ function normalizeConnectorRunTimeoutMs(value: unknown): number | undefined {
   return Math.floor(value);
 }
 
+function normalizeConnectorRunPayloadContinueDialogId(payload: unknown) {
+  if (!isRecord(payload)) return payload;
+  const dialogLineage = normalizeAgentRunDialogLineage({
+    continueDialogId: payload.continueDialogId,
+  });
+  const normalizedPayload = { ...payload };
+  if (dialogLineage.continueDialogId) {
+    normalizedPayload.continueDialogId = dialogLineage.continueDialogId;
+  } else {
+    delete normalizedPayload.continueDialogId;
+  }
+  return normalizedPayload;
+}
+
 export async function handleConnectorRunMessage(
   message: string,
   send: (message: string) => void,
@@ -365,6 +418,12 @@ export async function handleConnectorRunMessage(
     return;
   }
   if (parsed?.type !== "agent.run" || typeof parsed.requestId !== "string") return;
+  if (isRecord(parsed)) {
+    parsed = {
+      ...parsed,
+      payload: normalizeConnectorRunPayloadContinueDialogId(parsed.payload),
+    };
+  }
   const agentConfig = parsed.payload?.agentConfig ?? {};
   const sendProgress = (progress: ConnectorRunProgress) => {
     send(JSON.stringify({
@@ -392,6 +451,11 @@ export async function handleConnectorRunMessage(
   try {
     const machinePermissionPolicy = resolveMachineRunPermissionPolicy(agentConfig);
     const runtimePolicy = runtimePolicyFromConnectorPayload(parsed);
+    const hostRuntimeConfig = resolveHostRuntimeConfigFromEnv({
+      env: runtimeEnv,
+      surface: agentConfig.apiSource === "cli" ? "connector-cli" : "connector-local",
+      workspaceBinding: requestsTaskWorktree(runtimePolicy) ? "default-cwd" : "explicit-cwd",
+    });
     const userInput = String(parsed.payload?.userInput ?? "");
     const timeout = normalizeConnectorRunTimeoutMs(parsed.payload?.timeoutMs);
     let cwd = resolveConnectorRunCwd({ env: runtimeEnv, policy: machinePermissionPolicy });
@@ -414,7 +478,7 @@ export async function handleConnectorRunMessage(
         artifactCwd = prepared.path;
       }
       const runtimePermissionPolicy = !hasExplicitMachinePermissions(agentConfig)
-        ? runtimeWorkspacePermissionPolicy(runtimePolicy, cwd)
+        ? runtimeWorkspacePermissionPolicy(runtimePolicy, hostRuntimeConfig, cwd)
         : null;
       const effectivePermissionPolicy = scopePermissionPolicyToRuntimeWorkspace(
         runtimePermissionPolicy ?? machinePermissionPolicy,
@@ -472,17 +536,18 @@ export async function handleConnectorRunMessage(
           updatedAt: Date.now(),
         });
       }, 15_000);
+      const effectiveRuntimeEnv = withForwardedUserAuthToken(runtimeEnv, parsed);
       const result = await executeCli(provider, materializedPrompt.prompt, {
         model: agentConfig.model || undefined,
         timeout,
         cwd,
         yolo: true,
         env: {
-          NOLO_SERVER: runtimeEnv.NOLO_SERVER || runtimeEnv.NOLO_SERVER_URL || runtimeEnv.BASE_URL,
-          NOLO_SERVER_URL: runtimeEnv.NOLO_SERVER_URL || runtimeEnv.NOLO_SERVER || runtimeEnv.BASE_URL,
-          BASE_URL: runtimeEnv.BASE_URL || runtimeEnv.NOLO_SERVER || runtimeEnv.NOLO_SERVER_URL,
-          AUTH_TOKEN: runtimeEnv.AUTH_TOKEN || runtimeEnv.AUTH || runtimeEnv.NOLO_MACHINE_API_KEY,
-          NOLO_MACHINE_API_KEY: runtimeEnv.NOLO_MACHINE_API_KEY || runtimeEnv.AUTH_TOKEN || runtimeEnv.AUTH,
+          NOLO_SERVER: effectiveRuntimeEnv.NOLO_SERVER || effectiveRuntimeEnv.NOLO_SERVER_URL || effectiveRuntimeEnv.BASE_URL,
+          NOLO_SERVER_URL: effectiveRuntimeEnv.NOLO_SERVER_URL || effectiveRuntimeEnv.NOLO_SERVER || effectiveRuntimeEnv.BASE_URL,
+          BASE_URL: effectiveRuntimeEnv.BASE_URL || effectiveRuntimeEnv.NOLO_SERVER || effectiveRuntimeEnv.NOLO_SERVER_URL,
+          AUTH_TOKEN: effectiveRuntimeEnv.AUTH_TOKEN || effectiveRuntimeEnv.AUTH || effectiveRuntimeEnv.NOLO_MACHINE_API_KEY,
+          NOLO_MACHINE_API_KEY: effectiveRuntimeEnv.NOLO_MACHINE_API_KEY || effectiveRuntimeEnv.AUTH_TOKEN || effectiveRuntimeEnv.AUTH,
         },
       }).finally(() => clearInterval(heartbeat));
       logConnectorRun("agent.run.cli.result", {
@@ -518,13 +583,13 @@ export async function handleConnectorRunMessage(
       }));
       return;
     }
-    if (!requestsLocalWorkspaceRuntime(runtimePolicy)) {
+    if (!requestsLocalWorkspaceRuntime(runtimePolicy) && !isMachineBoundLocalCustomProvider(agentConfig)) {
       throw new Error("Connector can only execute non-CLI agents when runtimeToolPolicySnapshot requests a local workspace runtime.");
     }
     baseSha = await readConnectorGitHead(cwd);
     const result = await runConnectorLocalRuntimeAgent({
       parsed,
-      runtimeEnv,
+      runtimeEnv: withForwardedUserAuthToken(runtimeEnv, parsed),
       cwd,
       fetchImpl,
       onProgress: sendProgress,