nolo-cli 0.1.30 → 0.1.32

package/client/agentRun.ts

@@ -1,38 +1,30 @@
 import { existsSync } from "node:fs";
 import { join } from "node:path";
-import { runLocalAgentTurn } from "../agentRuntimeLocal";
-import { LOCAL_AGENT_CONFIG_MISSING_CODE } from "../agent-runtime/localLoop";
-import type { LocalAgentToolEvent } from "../agent-runtime/localLoop";
+import { normalizeAgentRunDialogLineage } from "../ai/agent/agentRunDialogLineage";
 import type { AgentRuntimeHostAdapter, AgentRuntimeRequestedMode } from "../agentRuntimeLocal";
 import type { EnvLike } from "../cliEnvHelpers";
 import type { OutputLike } from "../cliIoTypes";
-import { createCliLocalRuntimeAdapter } from "./localRuntimeAdapter";
-import { createStreamingTextWriter } from "./streamingOutput";
-import { prependTaskRunPrompt, type TaskRunPromptContext } from "./taskRunPrompt";
+import type { TaskRunPromptContext } from "./taskRunPrompt";
+import { type TaskRunRecorder } from "./agentRunTaskRunRecorder";
+import { buildUserInputContent } from "./agentRunInput";
 import {
-  formatToolTraceEvent,
-  nextLocalToolRoundLimit,
-  parseLocalToolRoundLimitError,
-  resolveLocalToolRoundRetryLimit,
-  shouldCollectLocalToolEvidence,
-  shouldTraceLocalTools,
-  summarizeLocalToolEvidence,
-  type TaskRunToolEvidence,
-} from "./agentRunLocalExecution";
-import {
-  findServerPlatformTools,
   resolveRequestedRuntimeMode,
   shouldAttemptAutoLocal,
-  shouldShowUsage,
   shouldSkipAutoLocalForServerPlatformTools,
   shouldUseScriptBridge,
 } from "./agentRunRuntimeSelection";
+import {
+  isMissingLocalAgentConfigError,
+  refreshMissingLocalAgentConfig,
+  resolveLocalRuntimeAdapter,
+  runInjectedLocalAgentTurn,
+  runLocalAgentTurnWithAutoRoundExpansion,
+} from "./agentRunLocalExecutor";
+import { runHttpAgentTurn } from "./agentRunServerTransport";
 export { classifyTaskRunReviewStatus } from "./agentRunLocalExecution";
 export { findServerPlatformTools, shouldUseScriptBridge } from "./agentRunRuntimeSelection";
-
-type TaskRunAgentRole = "pm" | "frontend" | "fullstack" | "reviewer" | "codex";
 
-type RunAgentTurnOptions = {
+export type RunAgentTurnOptions = {
   agentName: string;
   agentKey: string;
   serverUrl: string;
@@ -57,14 +49,7 @@ type RunAgentTurnOptions = {
   timeoutMs?: number;
   traceTools?: boolean;
   taskRunContext?: TaskRunPromptContext;
-  taskRunRecorder?: (args: {
-    options: RunAgentTurnOptions;
-    status: "running" | "completed" | "failed";
-    dialogId?: string;
-    resultSummary?: string;
-    errorCode?: string;
-    toolEvidence?: TaskRunToolEvidence;
-  }) => Promise<void>;
+  taskRunRecorder?: TaskRunRecorder<RunAgentTurnOptions>;
   scriptPathExists?: (path: string) => boolean;
   fetchImpl?: typeof fetch;
 };
@@ -74,241 +59,12 @@ export type RunAgentTurnResult = {
   dialogId?: string;
   streamInterrupted?: boolean;
 };
-
-function resolveServerPlatformToolNames(agentConfig: any) {
-  return findServerPlatformTools([
-    ...(Array.isArray(agentConfig?.toolNames) ? agentConfig.toolNames : []),
-    ...(Array.isArray(agentConfig?.runtimeToolPolicy?.agentTools)
-      ? agentConfig.runtimeToolPolicy.agentTools
-      : []),
-  ]);
-}
-
-function resolveAuthToken(env: EnvLike) {
-  return env.AUTH_TOKEN || env.AUTH || env.BENCHMARK_AUTH_TOKEN || "";
-}
-
-function buildDefaultLocalRuntimeAdapter(options: RunAgentTurnOptions) {
-  return createCliLocalRuntimeAdapter({
-    env: options.env,
-    fetchImpl: options.fetchImpl,
-    cwd: options.localRuntimeCwd,
-    output: options.output,
-  });
-}
-
-function resolveLocalRuntimeAdapter(options: RunAgentTurnOptions) {
-  return (
-    options.localRuntimeAdapter ||
-    options.localRuntimeAdapterFactory?.(options.env, { cwd: options.localRuntimeCwd }) ||
-    buildDefaultLocalRuntimeAdapter(options)
-  );
-}
-
-function buildUserInputContent(message: string, imageUrls: string[] = []) {
-  if (imageUrls.length === 0) return message;
-  return [
-    ...(message.trim() ? [{ type: "text" as const, text: message }] : []),
-    ...imageUrls.map((url) => ({
-      type: "image_url" as const,
-      image_url: { url },
-    })),
-  ];
-}
-
-function isMissingLocalAgentConfigError(error: unknown, agentRef: string) {
-  return Boolean(
-    error &&
-      typeof error === "object" &&
-      "code" in error &&
-      (error as { code?: string; agentRef?: string }).code === LOCAL_AGENT_CONFIG_MISSING_CODE &&
-      (error as { code?: string; agentRef?: string }).agentRef === agentRef
-  );
-}
-
 
-function inferTaskRunAgentRole(agentRef: string): TaskRunAgentRole {
-  const normalized = agentRef.toLowerCase();
-  if (normalized.includes("project-manager") || normalized.includes("manager")) return "pm";
-  if (normalized.includes("frontend")) return "frontend";
-  if (normalized.includes("fullstack")) return "fullstack";
-  if (normalized.includes("review")) return "reviewer";
-  return "codex";
+function resolveAuthToken(env: EnvLike) {
+  return env.AUTH_TOKEN || env.AUTH || env.BENCHMARK_AUTH_TOKEN || "";
 }
 
-async function runTaskRunCli(args: {
-  options: RunAgentTurnOptions;
-  cliArgs: string[];
-}) {
-  const scriptPath = join(args.options.scriptDir, "taskRun.ts");
-  const proc = Bun.spawn({
-    cmd: [process.execPath, scriptPath, ...args.cliArgs],
-    stdout: "pipe",
-    stderr: "pipe",
-    env: {
-      ...process.env,
-      ...args.options.env,
-      BASE_URL: args.options.serverUrl,
-    },
-  });
-  const [stdout, stderr, exitCode] = await Promise.all([
-    new Response(proc.stdout).text(),
-    new Response(proc.stderr).text(),
-    proc.exited,
-  ]);
-  if (exitCode !== 0) {
-    throw new Error((stderr || stdout || `taskRun.ts exited ${exitCode}`).trim());
-  }
-}
-
-async function defaultTaskRunRecorder(args: {
-  options: RunAgentTurnOptions;
-  status: "running" | "completed" | "failed";
-  dialogId?: string;
-  resultSummary?: string;
-  errorCode?: string;
-  toolEvidence?: TaskRunToolEvidence;
-}) {
-  const context = args.options.taskRunContext;
-  if (!context?.rowDbKey) return;
-  const role = inferTaskRunAgentRole(args.options.agentName || args.options.agentKey);
-  if (role === "reviewer" && args.status !== "running") {
-    await runTaskRunCli({
-      options: args.options,
-      cliArgs: [
-        "request-review",
-        "--row-dbkey",
-        context.rowDbKey,
-        "--base-url",
-        args.options.serverUrl,
-        "--reviewer-agent-key",
-        args.options.agentKey,
-        ...(context.artifactIds?.length ? ["--artifact-ids", context.artifactIds.join(",")] : []),
-        ...(args.dialogId ? ["--dialog-id", args.dialogId] : []),
-      ],
-    });
-  }
-  await runTaskRunCli({
-    options: args.options,
-    cliArgs: [
-      "record-agent-run",
-      "--row-dbkey",
-      context.rowDbKey,
-      "--base-url",
-      args.options.serverUrl,
-      "--agent-key",
-      args.options.agentKey,
-      "--role",
-      role,
-      "--run-status",
-      args.status,
-      ...(context.workItemId ? ["--work-item-id", context.workItemId] : []),
-      ...(args.dialogId ? ["--dialog-id", args.dialogId] : []),
-      ...(args.resultSummary ? ["--result-summary", args.resultSummary.slice(0, 240)] : []),
-      ...(args.errorCode ? ["--error-code", args.errorCode] : []),
-      ...(args.toolEvidence?.toolsUsed?.length
-        ? ["--tools-used", args.toolEvidence.toolsUsed.join(",")]
-        : []),
-      ...(args.toolEvidence?.summary
-        ? ["--tool-trace-summary", JSON.stringify(args.toolEvidence.summary)]
-        : []),
-    ],
-  });
-  if (context.workItemId && args.dialogId) {
-    await runTaskRunCli({
-      options: args.options,
-      cliArgs: [
-        "update-work-item",
-        "--row-dbkey",
-        context.rowDbKey,
-        "--base-url",
-        args.options.serverUrl,
-        "--id",
-        context.workItemId,
-        "--dialog-ids",
-        args.dialogId,
-      ],
-    });
-  }
-  if (role === "reviewer" && args.status !== "running") {
-    const reviewStatus =
-      args.status === "failed" ? "blocked" : classifyTaskRunReviewStatus(args.resultSummary);
-    if (reviewStatus) {
-      await runTaskRunCli({
-        options: args.options,
-        cliArgs: [
-          "review-result",
-          "--row-dbkey",
-          context.rowDbKey,
-          "--base-url",
-          args.options.serverUrl,
-          "--review-status",
-          reviewStatus,
-          "--reviewer-agent-key",
-          args.options.agentKey,
-          ...(context.artifactIds?.length ? ["--artifact-ids", context.artifactIds.join(",")] : []),
-          ...(args.dialogId ? ["--dialog-id", args.dialogId] : []),
-        ],
-      });
-    }
-  }
-}
-
-async function recordTaskRunOutcome(args: {
-  options: RunAgentTurnOptions;
-  status: "running" | "completed" | "failed";
-  dialogId?: string;
-  resultSummary?: string;
-  errorCode?: string;
-  toolEvidence?: TaskRunToolEvidence;
-}) {
-  if (!args.options.taskRunContext?.rowDbKey) return;
-  try {
-    await (args.options.taskRunRecorder ?? defaultTaskRunRecorder)(args);
-  } catch (error) {
-    args.options.output.write(
-      `[nolo] task-run writeback failed: ${error instanceof Error ? error.message : String(error)}\n`
-    );
-  }
-}
-
-function formatUsage(usage: any, dialogId: unknown) {
-  const parts: string[] = [];
-  if (typeof dialogId === "string" && dialogId) parts.push(`dialog=${dialogId}`);
-
-  const input = usage?.input_tokens ?? usage?.prompt_tokens ?? 0;
-  const output = usage?.output_tokens ?? usage?.completion_tokens ?? 0;
-  if (input || output) parts.push(`tokens=${input}+${output}`);
-
-  return parts.length ? `  (${parts.join("  ")})` : "";
-}
-
-function buildTransportErrorHint(serverUrl: string, error: unknown) {
-  const endpoint = `${serverUrl}/api/agent/run`;
-  const reason = error instanceof Error ? error.message : String(error);
-
-  let detail =
-    `[nolo] Could not reach ${endpoint}.\n` +
-    `Reason: ${reason}\n`;
-
-  try {
-    const parsed = new URL(serverUrl);
-    if (parsed.hostname === "127.0.0.1" || parsed.hostname === "localhost") {
-      detail +=
-        "If you meant local dev, start the local API first.\n" +
-        "Otherwise set NOLO_SERVER to a reachable server, or re-run `nolo login --server https://nolo.chat`.\n";
-      return detail;
-    }
-  } catch {
-    // Keep the generic hint below when serverUrl is not a valid absolute URL.
-  }
-
-  detail +=
-    "Check NOLO_SERVER / BASE_URL and make sure the configured server is reachable.\n";
-  return detail;
-}
-
-async function runScriptBridge(options: RunAgentTurnOptions, scriptPath: string) {
+async function runScriptBridge(options: RunAgentTurnOptions, scriptPath: string) {
   options.output.write(`\n${options.agentName} -> working via local script...\n\n`);
   const proc = Bun.spawn({
     cmd: [
@@ -361,394 +117,45 @@ async function runScriptBridge(options: RunAgentTurnOptions, scriptPath: string)
   }
   return { exitCode };
 }
-
-async function runHttpAgentTurn(options: RunAgentTurnOptions, authToken: string) {
-  options.output.write(`\n${options.agentName} -> working...\n`);
-
-  const fetchImpl = options.fetchImpl ?? fetch;
-  let res: Response;
-  try {
-    res = await fetchImpl(`${options.serverUrl}/api/agent/run`, {
-      method: "POST",
-      headers: {
-        Authorization: `Bearer ${authToken}`,
-        "Content-Type": "application/json",
-      },
-      body: JSON.stringify({
-        agentKey: options.agentKey,
-        userInput: buildUserInputContent(
-          prependTaskRunPrompt(options.message, options.taskRunContext),
-          options.imageUrls
-        ),
-        runtimeContext: {
-          surface: "cli",
-          host: "terminal",
-          runtime: "bun",
-          entrypoint: "nolo-cli",
-          capabilities: ["text-io", "streaming", "slash-commands"],
-          ...(options.taskRunContext
-            ? {
-                taskRun: {
-                  rowDbKey: options.taskRunContext.rowDbKey,
-                  ...(options.taskRunContext.taskRunId
-                    ? { taskRunId: options.taskRunContext.taskRunId }
-                    : {}),
-                  ...(options.taskRunContext.workItemId
-                    ? { workItemId: options.taskRunContext.workItemId }
-                    : {}),
-                  ...(options.taskRunContext.artifactIds?.length
-                    ? { artifactIds: options.taskRunContext.artifactIds }
-                    : {}),
-                },
-              }
-            : {}),
-        },
-        ...(options.continueDialogId
-          ? { continueDialogId: options.continueDialogId }
-          : {}),
-        ...(options.spaceId ? { spaceId: options.spaceId } : {}),
-        ...(options.category ? { category: options.category } : {}),
-        ...(options.inheritedFromDialogKey
-          ? { inheritedFromDialogKey: options.inheritedFromDialogKey }
-          : {}),
-        ...(options.parentDialogId ? { parentDialogId: options.parentDialogId } : {}),
-        ...(options.background ? { background: true } : {}),
-        ...(typeof options.maxToolRounds === "number" ? { maxRounds: options.maxToolRounds } : {}),
-        ...(typeof options.timeoutMs === "number" ? { timeoutMs: options.timeoutMs } : {}),
-        stream: !options.noStream && !options.background,
-      }),
-    });
-  } catch (error) {
-    options.output.write(buildTransportErrorHint(options.serverUrl, error));
-    return { exitCode: 1 };
-  }
-
-  const contentType = res.headers.get("content-type") || "";
-  if (contentType.includes("text/event-stream") && res.body) {
-    const result = await readStreamingAgentRun(options, res);
-    await recordTaskRunOutcome({
-      options,
-      status: result.streamInterrupted
-        ? "running"
-        : result.exitCode === 0
-          ? "completed"
-          : "failed",
-      dialogId: result.dialogId,
-      ...(result.exitCode !== 0 ? { errorCode: "STREAM_FAILED" } : {}),
-    });
-    return result;
-  }
-
-  let data: any = {};
-  try {
-    data = await res.json();
-  } catch {
-    data = {};
-  }
-
-  if (!res.ok) {
-    options.output.write(`[nolo] Agent request failed: HTTP ${res.status}\n`);
-    if (data?.error || data?.message) {
-      options.output.write(`${data.error || data.message}\n`);
-    }
-    await recordTaskRunOutcome({
-      options,
-      status: "failed",
-      errorCode: `HTTP_${res.status}`,
-      resultSummary: String(data?.error || data?.message || "").trim() || undefined,
-    });
-    return { exitCode: 1 };
-  }
-
-  const content = String(data?.content ?? data?.message ?? "").trim();
-  if (content) {
-    options.output.write(`\n${options.agentName} > ${content}\n`);
-  } else {
-    options.output.write(`\n${options.agentName} > (no text response)\n`);
-  }
-
-  const usage = formatUsage(data?.usage, data?.dialogId);
-  if (usage && shouldShowUsage(options.env)) options.output.write(`${usage}\n`);
-  const result = {
-    exitCode: 0,
-    ...(typeof data?.dialogId === "string" && data.dialogId
-      ? { dialogId: data.dialogId }
-      : {}),
-  };
-  await recordTaskRunOutcome({
-    options,
-    status: options.background ? "running" : "completed",
-    dialogId: result.dialogId,
-    ...(!options.background && content ? { resultSummary: content } : {}),
-  });
-  return result;
-}
-
-async function runInjectedLocalAgentTurn(options: RunAgentTurnOptions) {
-  return runLocalAgentTurnWithAutoRoundExpansion(options, { reportFailure: true });
-}
-
-async function refreshMissingLocalAgentConfig(options: RunAgentTurnOptions) {
-  const adapter = resolveLocalRuntimeAdapter(options);
-  if (!adapter) return false;
-  const agentConfig = await adapter.loadAgentConfig(options.agentKey);
-  return Boolean(agentConfig);
-}
-
-async function runLocalAgentTurnWithAutoRoundExpansion(
-  options: RunAgentTurnOptions,
-  settings: { reportFailure: boolean }
-) {
-  const maxRetryLimit = resolveLocalToolRoundRetryLimit(options);
-  let currentMaxToolRounds = options.maxToolRounds;
-  let lastResult: Awaited<ReturnType<typeof runLocalAgentTurnForCli>> | null = null;
-
-  while (true) {
-    const attemptOptions = {
-      ...options,
-      ...(typeof currentMaxToolRounds === "number" ? { maxToolRounds: currentMaxToolRounds } : {}),
-    };
-    const result = await runLocalAgentTurnForCli(attemptOptions, { reportFailure: false });
-    lastResult = result;
-    if (result.exitCode === 0) return result;
-
-    const exhaustedRounds = parseLocalToolRoundLimitError(result.localError);
-    if (exhaustedRounds === null) break;
-
-    const nextMaxToolRounds = nextLocalToolRoundLimit(exhaustedRounds);
-    if (nextMaxToolRounds > maxRetryLimit) break;
-
-    options.output.write(
-      `[nolo] Local agent used all ${exhaustedRounds} tool rounds; retrying with ${nextMaxToolRounds}.\n`
-    );
-    currentMaxToolRounds = nextMaxToolRounds;
-  }
-
-  if (settings.reportFailure && lastResult?.localError) {
-    options.output.write(
-      `[nolo] Local agent run failed: ${
-        lastResult.localError instanceof Error ? lastResult.localError.message : String(lastResult.localError)
-      }\n`
-    );
-    await recordTaskRunOutcome({
-      options,
-      status: "failed",
-      errorCode: "LOCAL_AGENT_FAILED",
-      resultSummary:
-        lastResult.localError instanceof Error ? lastResult.localError.message : String(lastResult.localError),
-      toolEvidence: lastResult.toolEvidence,
-    });
-  }
-  return lastResult ?? { exitCode: 1 };
-}
-
-async function runLocalAgentTurnForCli(
-  options: RunAgentTurnOptions,
-  settings: { reportFailure: boolean }
-) {
-  const adapter = resolveLocalRuntimeAdapter(options);
-  if (!adapter) {
-    options.output.write("[nolo] Local runtime was requested but no local runtime adapter is available.\n");
-    return { exitCode: 1 };
-  }
 
-  options.output.write(`\n${options.agentName} -> working locally...\n`);
-  const toolEvents: LocalAgentToolEvent[] = [];
-  try {
-    const traceLocalTools = shouldTraceLocalTools(options);
-    const collectToolEvidence = shouldCollectLocalToolEvidence(options);
-    const result = await runLocalAgentTurn({
-      adapter,
-      agentRef: options.agentKey,
-      input: buildUserInputContent(
-        prependTaskRunPrompt(options.message, options.taskRunContext),
-        options.imageUrls
-      ),
-      continueDialogId: options.continueDialogId,
-      spaceId: options.spaceId,
-      category: options.category,
-      inheritedFromDialogKey: options.inheritedFromDialogKey,
-      parentDialogId: options.parentDialogId,
-      background: options.background,
-      noStream: options.noStream,
-      maxToolRounds: options.maxToolRounds,
-      ...(traceLocalTools || collectToolEvidence
-        ? {
-            onToolEvent: (event) => {
-              if (collectToolEvidence) toolEvents.push(event);
-              if (traceLocalTools) options.output.write(formatToolTraceEvent(event));
-            },
-          }
-        : {}),
-    });
-    const content = result.content.trim();
-    if (content) {
-      options.output.write(`\n${options.agentName} > ${content}\n`);
-    } else {
-      options.output.write(`\n${options.agentName} > (no text response)\n`);
-    }
-    await recordTaskRunOutcome({
-      options,
-      status: options.background ? "running" : "completed",
-      dialogId: result.dialogId,
-      ...(!options.background && content ? { resultSummary: content } : {}),
-      toolEvidence: summarizeLocalToolEvidence(toolEvents),
-    });
-    return { exitCode: 0, dialogId: result.dialogId };
-  } catch (error) {
-    if (settings.reportFailure) {
-      options.output.write(
-        `[nolo] Local agent run failed: ${
-          error instanceof Error ? error.message : String(error)
-        }\n`
-      );
-    }
-    return { exitCode: 1, localError: error, toolEvidence: summarizeLocalToolEvidence(toolEvents) };
-  }
-}
-
-async function readStreamingAgentRun(
-  options: RunAgentTurnOptions,
-  res: Response,
-): Promise<RunAgentTurnResult> {
-  const reader = res.body?.getReader();
-  if (!reader) {
-    options.output.write("[nolo] Agent stream response did not include a readable body.\n");
-    return { exitCode: 1 };
-  }
-
-  const decoder = new TextDecoder();
-  const writer = createStreamingTextWriter({
-    write: (chunk) => options.output.write(chunk),
-  });
-  let buffer = "";
-  let content = "";
-  let dialogId: string | undefined;
-  let usage: any;
-  let hasPrintedLabel = false;
-
-  const printLabel = () => {
-    if (hasPrintedLabel) return;
-    options.output.write(`\n${options.agentName} > `);
-    hasPrintedLabel = true;
-  };
-
-  const handlePayload = (payload: any) => {
-    if (typeof payload?.dialogId === "string" && payload.dialogId.trim()) {
-      dialogId = payload.dialogId;
-    }
-    if (payload?.error || payload?.type === "error") {
-      throw new Error(String(payload.error || payload.message || "Agent stream failed"));
-    }
-    if (payload?.type === "done") {
-      usage = payload.usage;
-      return;
-    }
-    if (payload?.type === "dialog" || payload?.type === "status") {
-      return;
-    }
-
-    const chunk =
-      payload?.type === "text"
-        ? payload.content
-        : typeof payload?.chunk === "string"
-          ? payload.chunk
-          : "";
-    if (!chunk) return;
-
-    printLabel();
-    content += chunk;
-    writer.push(chunk);
-  };
-
-  try {
-    while (true) {
-      const { done, value } = await reader.read();
-      if (done) break;
-
-      buffer += decoder.decode(value, { stream: true });
-      const events = buffer.split("\n\n");
-      buffer = events.pop() ?? "";
-
-      for (const event of events) {
-        const dataLines = event
-          .split("\n")
-          .filter((line) => line.startsWith("data:"))
-          .map((line) => line.slice(5).trim())
-          .filter(Boolean);
-        for (const raw of dataLines) {
-          handlePayload(JSON.parse(raw));
-        }
-      }
-    }
-    if (buffer.trim()) {
-      const raw = buffer
-        .split("\n")
-        .find((line) => line.startsWith("data:"))
-        ?.slice(5)
-        .trim();
-      if (raw) handlePayload(JSON.parse(raw));
-    }
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    if (dialogId) {
-      options.output.write(
-        `\n[nolo] Agent stream transport interrupted after dialog ${dialogId} was created: ${message}\n`
-      );
-      options.output.write("[nolo] The agent run may still finish on the server; read the dialog before retrying.\n");
-      return { exitCode: 0, dialogId, streamInterrupted: true };
-    }
-    options.output.write(`\n[nolo] Agent stream failed: ${message}\n`);
-    return { exitCode: 1 };
-  } finally {
-    writer.flushAll();
-  }
-
-  if (!content) {
-    options.output.write(`\n${options.agentName} > (no text response)\n`);
-  } else {
-    options.output.write("\n");
-  }
-
-  const usageText = formatUsage(usage, dialogId);
-  if (usageText && shouldShowUsage(options.env)) options.output.write(`${usageText}\n`);
-  return {
-    exitCode: 0,
-    ...(dialogId ? { dialogId } : {}),
-  };
-}
-
 export async function runAgentTurn(options: RunAgentTurnOptions) {
+  const dialogLineage = normalizeAgentRunDialogLineage(options);
+  const effectiveOptions: RunAgentTurnOptions = {
+    ...options,
+    continueDialogId: dialogLineage.continueDialogId,
+    inheritedFromDialogKey: dialogLineage.inheritedFromDialogKey,
+    parentDialogId: dialogLineage.parentDialogId,
+  };
   const authToken = resolveAuthToken(options.env);
-  const scriptPath = join(options.scriptDir, "chatWithAgent.ts");
+  const scriptPath = join(effectiveOptions.scriptDir, "chatWithAgent.ts");
   const scriptPathExists = (options.scriptPathExists ?? existsSync)(scriptPath);
-  const runtimeMode = resolveRequestedRuntimeMode(options);
+  const runtimeMode = resolveRequestedRuntimeMode(effectiveOptions);
 
   if (runtimeMode === "local") {
-    return runInjectedLocalAgentTurn(options);
+    return runInjectedLocalAgentTurn(effectiveOptions);
   }
 
-  if (runtimeMode === "auto" && shouldAttemptAutoLocal(options)) {
+  if (runtimeMode === "auto" && shouldAttemptAutoLocal(effectiveOptions)) {
     const skipLocal = await shouldSkipAutoLocalForServerPlatformTools({
-      ...options,
-      resolveLocalRuntimeAdapter: () => resolveLocalRuntimeAdapter(options),
+      ...effectiveOptions,
+      resolveLocalRuntimeAdapter: () => resolveLocalRuntimeAdapter(effectiveOptions),
     });
     if (!skipLocal) {
-      const localResult = await runLocalAgentTurnWithAutoRoundExpansion(options, { reportFailure: false });
+      const localResult = await runLocalAgentTurnWithAutoRoundExpansion(effectiveOptions, { reportFailure: false });
       if (localResult.exitCode === 0) {
         return {
           exitCode: localResult.exitCode,
           ...(localResult.dialogId ? { dialogId: localResult.dialogId } : {}),
         };
       }
-      if (isMissingLocalAgentConfigError(localResult.localError, options.agentKey)) {
-        options.output.write(
+      if (isMissingLocalAgentConfigError(localResult.localError, effectiveOptions.agentKey)) {
+        effectiveOptions.output.write(
           `[nolo] Local agent config was missing; refreshing from the configured server and retrying local once.\n`
         );
         try {
-          const refreshed = await refreshMissingLocalAgentConfig(options);
+          const refreshed = await refreshMissingLocalAgentConfig(effectiveOptions);
           if (refreshed) {
-            const retriedLocalResult = await runLocalAgentTurnWithAutoRoundExpansion(options, {
+            const retriedLocalResult = await runLocalAgentTurnWithAutoRoundExpansion(effectiveOptions, {
               reportFailure: false,
             });
             if (retriedLocalResult.exitCode === 0) {
@@ -766,16 +173,16 @@ export async function runAgentTurn(options: RunAgentTurnOptions) {
   }
 
   if (shouldUseScriptBridge({ hasAuthToken: Boolean(authToken), scriptPathExists })) {
-    return runScriptBridge(options, scriptPath);
+    return runScriptBridge(effectiveOptions, scriptPath);
   }
-
-  if (!authToken) {
-    options.output.write(
-      "[nolo] This install needs an auth token before it can talk to agents.\n" +
-        "Set AUTH_TOKEN, or use the repo-local CLI where the dev script bridge is available.\n"
-    );
+
+  if (!authToken) {
+    effectiveOptions.output.write(
+      "[nolo] This install needs an auth token before it can talk to agents.\n" +
+        "Set AUTH_TOKEN, or use the repo-local CLI where the dev script bridge is available.\n"
+    );
     return { exitCode: 1 };
   }
 
-  return runHttpAgentTurn(options, authToken);
-}
+  return runHttpAgentTurn(effectiveOptions, { authToken });
+}