@ricsam/r5dctl 0.0.60 → 0.0.62

package/dist/cjs/cli.cjs

@@ -30,7 +30,9 @@ var cli_exports = {};
 __export(cli_exports, {
   advanceTransientDevicePollBackoff: () => advanceTransientDevicePollBackoff,
   collectK8sUsage: () => collectK8sUsage,
-  dispatchBranchAgentCommand: () => dispatchBranchAgentCommand,
+  dispatchMergeCommand: () => dispatchMergeCommand,
+  dispatchSessionRunCommand: () => dispatchSessionRunCommand,
+  followR5dctlSession: () => followR5dctlSession,
   formatK8sCpu: () => formatK8sCpu,
   formatK8sMemory: () => formatK8sMemory,
   formatProcessAge: () => formatProcessAge,
@@ -41,8 +43,9 @@ __export(cli_exports, {
   getTransientDevicePollDelay: () => getTransientDevicePollDelay,
   handleAuthLogin: () => handleAuthLogin,
   main: () => main,
+  parseAnswerEnvRequestCommandArgs: () => parseAnswerEnvRequestCommandArgs,
   parseAnswerFlags: () => parseAnswerFlags,
-  parseBranchAgentCommand: () => parseBranchAgentCommand,
+  parseAnswerQuestionsCommandArgs: () => parseAnswerQuestionsCommandArgs,
   parseConversationRenderArgs: () => parseConversationRenderArgs,
   parseConversationWorkDetailArgs: () => parseConversationWorkDetailArgs,
   parseEnvFlags: () => parseEnvFlags,
@@ -50,15 +53,14 @@ __export(cli_exports, {
   parseGetEnvsArgs: () => parseGetEnvsArgs,
   parseGlobalArgs: () => parseGlobalArgs,
   parseK8sUsageArgs: () => parseK8sUsageArgs,
+  parseMergeCommand: () => parseMergeCommand,
   parsePromptArgs: () => parsePromptArgs,
   parsePsHistoryArgs: () => parsePsHistoryArgs,
   parsePsListArgs: () => parsePsListArgs,
+  parseSessionRunCommand: () => parseSessionRunCommand,
   parseSetEnvArgs: () => parseSetEnvArgs,
   parseShellArgs: () => parseShellArgs,
   readDotenvFile: () => readDotenvFile,
-  renderBranchAgentMerge: () => renderBranchAgentMerge,
-  renderBranchAgentStart: () => renderBranchAgentStart,
-  renderBranchAgentStatus: () => renderBranchAgentStatus,
   renderConversationNodeResponse: () => renderConversationNodeResponse,
   renderConversationOverviewResponse: () => renderConversationOverviewResponse,
   renderConversationResponse: () => renderConversationResponse,
@@ -69,8 +71,11 @@ __export(cli_exports, {
   renderProcessHistory: () => renderProcessHistory,
   renderProcessInspection: () => renderProcessInspection,
   renderProcessList: () => renderProcessList,
+  renderSessionRunStart: () => renderSessionRunStart,
+  renderSessionRunStatus: () => renderSessionRunStatus,
   renderWorkspaceStatus: () => renderWorkspaceStatus,
   renderWorkspaceSync: () => renderWorkspaceSync,
+  renderWorktreeMerge: () => renderWorktreeMerge,
   resolveCommandExecution: () => resolveCommandExecution,
   runR5dctlCli: () => runR5dctlCli,
   summarizeEnvData: () => summarizeEnvData,
@@ -92,15 +97,12 @@ const CHAT_MODES = /* @__PURE__ */ new Set([
   "plan",
   "build",
   "agent",
-  "explore",
-  "test",
-  "research",
   "security_review",
   "large_diff_remediation",
   "merge_conflict_resolution"
 ]);
+const R5DCTL_SESSION_MODES = /* @__PURE__ */ new Set(["ask", "plan", "build", "agent"]);
 const MODEL_TIERS = /* @__PURE__ */ new Set(["low", "medium", "high", "max"]);
-const AGENT_TYPES = /* @__PURE__ */ new Set(["research", "debug", "test"]);
 const R5DCTL_PACKAGE_NAME = "@ricsam/r5dctl";
 const CLI_GLOBAL_OPTION_HELP = [
   "--base-url <url>",
@@ -154,17 +156,24 @@ const K8S_HELP_TEXT = [
   "Show current and rolling CPU and memory usage for managed-vCluster workload containers.",
   ""
 ].join("\n");
-const AGENT_HELP_TEXT = [
+const SESSION_RUN_HELP_TEXT = [
   "Usage:",
-  '  r5dctl -p <project> agent start --worker <label> --source worktree:<branch> <research|debug|test> "<prompt>"',
-  "  r5dctl agent status <session-id>",
-  '  r5dctl agent prompt --worker <label> <session-id> "<prompt>"',
-  "  r5dctl agent merge --worker <label> <session-id>",
-  "  r5dctl agent stop <session-id>",
-  '  r5dctl agent finish-merge --worker <label> <resolver-session-id> --summary "<summary>"',
+  '  r5dctl -p <project> session start --worker <label> --worktree <branch> --model <tier> [-f|--follow|--watch] [--tools] "<prompt>"',
+  '  r5dctl -p <project> session start --worker <label> --new-worktree <branch> --source worktree:<branch> --model <tier> [-f|--follow|--watch] [--tools] "<prompt>"',
+  "  r5dctl session status <session-id>",
+  '  r5dctl session prompt --worker <label> --mode <mode> --model <tier> <session-id> "<prompt>"',
+  "  r5dctl session stop <session-id>",
   "",
-  "Create, inspect, resume, stop, and merge independent branch agents.",
-  "The source is the named branch worktree, including its committed and uncommitted files.",
+  "Create, inspect, resume, and stop ordinary agent sessions.",
+  "Use -f/--follow/--watch to attach after a start; Ctrl-C detaches without stopping the session.",
+  ""
+].join("\n");
+const MERGE_HELP_TEXT = [
+  "Usage:",
+  "  r5dctl -p <project> merge [--worker <label>] [--create-conflict-worktree|--launch-conflict-resolution-agent] <source-worktree>",
+  '  r5dctl -p <project> merge finish --worker <label> [--summary "<summary>"] <conflict-worktree>',
+  "",
+  "Merge a managed worktree into its recorded parent worktree.",
   ""
 ].join("\n");
 const SHARED_HELP_ENTRIES = [
@@ -234,7 +243,7 @@ const SHARED_HELP_ENTRIES = [
   { section: "sessions", usage: "-s <session-id> delete session", description: "Delete a session." },
   {
     section: "sessions",
-    usage: "-s <session-id> conversation [--raw] [--tools] [--system]",
+    usage: "-s <session-id> conversation [--raw] [--tools] [--system] [-f|--follow|--watch]",
     description: "Read the agent request transcript in human-readable form."
   },
   {
@@ -254,17 +263,32 @@ const SHARED_HELP_ENTRIES = [
   },
   {
     section: "sessions",
-    usage: '-s <session-id> prompt --mode <mode> --model <tier> "<message>"',
-    description: "Send a prompt to a session."
+    usage: '-p <project> session start --worker <label> (--worktree <branch>|--new-worktree <branch> --source worktree:<branch>) --model <tier> [-f|--follow|--watch] [--tools] "<prompt>"',
+    description: "Start an ordinary agent session on an explicit existing or new worktree."
   },
   {
     section: "sessions",
-    usage: '-s <session-id> answer-questions -a1 "<answer>" -a2 "<answer>" ...',
+    usage: "session status <session-id>",
+    description: "Show asynchronous session execution status."
+  },
+  {
+    section: "sessions",
+    usage: 'session prompt --worker <label> --mode <mode> --model <tier> <session-id> "<prompt>"',
+    description: "Queue a prompt or start a new session generation."
+  },
+  {
+    section: "sessions",
+    usage: "session stop <session-id>",
+    description: "Stop an active session generation."
+  },
+  {
+    section: "sessions",
+    usage: '-s <session-id> answer-questions --worker <label> --mode <mode> --model <tier> -a1 "<answer>" ...',
     description: "Answer pending questions in order."
   },
   {
     section: "sessions",
-    usage: "-s <session-id> answer-env-request [-e KEY=value] [--context <text>]",
+    usage: "-s <session-id> answer-env-request --worker <label> --mode <mode> --model <tier> [-e KEY=value] [--context <text>]",
     description: "Answer a pending environment variable request with values, context, or both."
   },
   {
@@ -289,34 +313,14 @@ const SHARED_HELP_ENTRIES = [
   },
   { section: "processes", usage: "ps stop <run-id>", description: "Gracefully stop an active process with SIGTERM." },
   {
-    section: "agents",
-    usage: '-p <project> agent start --worker <label> --source worktree:<branch> <research|debug|test> "<prompt>"',
-    description: "Create a branch from an explicit worktree source and start an independent agent."
-  },
-  {
-    section: "agents",
-    usage: "agent status <session-id>",
-    description: "Show branch-agent execution, publication, and merge status."
-  },
-  {
-    section: "agents",
-    usage: 'agent prompt --worker <label> <session-id> "<prompt>"',
-    description: "Queue a prompt or resume an idle branch agent on the selected worker."
-  },
-  {
-    section: "agents",
-    usage: "agent merge --worker <label> <session-id>",
-    description: "Merge a terminal branch agent into its recorded parent worktree."
-  },
-  {
-    section: "agents",
-    usage: "agent stop <session-id>",
-    description: "Stop a branch agent or merge resolver."
+    section: "merge",
+    usage: "-p <project> merge [--worker <label>] [--create-conflict-worktree|--launch-conflict-resolution-agent] <source-worktree>",
+    description: "Merge a worktree into its recorded parent, with an explicit conflict strategy."
   },
   {
-    section: "agents",
-    usage: 'agent finish-merge --worker <label> <resolver-session-id> --summary "<summary>"',
-    description: "Publish and finalize a manually resolved merge."
+    section: "merge",
+    usage: '-p <project> merge finish --worker <label> [--summary "<summary>"] <conflict-worktree>',
+    description: "Publish and finish a manually resolved conflict worktree."
   }
 ];
 const HELP_SECTION_ORDER = [
@@ -329,7 +333,7 @@ const HELP_SECTION_ORDER = [
   "kubernetes",
   "processes",
   "shell",
-  "agents"
+  "merge"
 ];
 const HELP_SECTION_TITLES = {
   auth: "Auth",
@@ -341,7 +345,7 @@ const HELP_SECTION_TITLES = {
   kubernetes: "Kubernetes",
   processes: "Processes",
   shell: "Shell",
-  agents: "Branch agents"
+  merge: "Worktree merging"
 };
 function getCliHelpText() {
   const entries = [...CLI_ONLY_HELP_ENTRIES, ...SHARED_HELP_ENTRIES];
@@ -488,9 +492,10 @@ function parseOptionalFlagValue(args, flag, shortFlag) {
 function hasBooleanFlag(args, flag) {
   return args.includes(flag);
 }
-function parseAgentOperands(args, valueFlags, options = {}) {
+function parseCommandOperands(args, valueFlags, booleanFlags = /* @__PURE__ */ new Map(), family = "command", allowFlagLikeValuesAfter = Number.POSITIVE_INFINITY) {
   const positionals = [];
   const values = /* @__PURE__ */ new Map();
+  const booleans = /* @__PURE__ */ new Set();
   let parseOptions = true;
   for (let index = 0; index < args.length; index += 1) {
     const arg = args[index];
@@ -498,6 +503,12 @@ function parseAgentOperands(args, valueFlags, options = {}) {
       parseOptions = false;
       continue;
     }
+    const booleanFlag = parseOptions ? booleanFlags.get(arg) : void 0;
+    if (booleanFlag) {
+      if (booleans.has(booleanFlag)) throw new Error(`${booleanFlag} may only be provided once`);
+      booleans.add(booleanFlag);
+      continue;
+    }
     const inlineFlag = parseOptions ? [...valueFlags].find((flag) => arg.startsWith(`${flag}=`)) : void 0;
     if (inlineFlag) {
       if (values.has(inlineFlag)) throw new Error(`${inlineFlag} may only be provided once`);
@@ -514,18 +525,18 @@ function parseAgentOperands(args, valueFlags, options = {}) {
       index += 1;
       continue;
     }
-    if (parseOptions && arg.startsWith("-") && positionals.length < (options.allowFlagLikeValuesAfter ?? Number.POSITIVE_INFINITY)) {
-      throw new Error(`Unknown agent flag: ${arg}`);
+    if (parseOptions && arg.startsWith("-") && positionals.length < allowFlagLikeValuesAfter) {
+      throw new Error(`Unknown ${family} flag: ${arg}`);
     }
     positionals.push(arg);
   }
-  return { positionals, values };
+  return { positionals, values, booleans };
 }
-function requireAgentWorker(values) {
+function requireWorker(values) {
   return requireValue(values.get("--worker")?.trim(), "--worker <label> is required");
 }
-function requireAgentSource(values) {
-  const raw = requireValue(values.get("--source")?.trim(), "--source worktree:<branch> is required for `agent start`");
+function parseWorktreeSource(rawValue) {
+  const raw = requireValue(rawValue?.trim(), "--source worktree:<branch> is required with --new-worktree");
   const separator = raw.indexOf(":");
   const type = raw.slice(0, separator);
   const branchName = raw.slice(separator + 1).trim();
@@ -534,61 +545,119 @@ function requireAgentSource(values) {
   }
   return { type, branchName };
 }
-function rejectAgentGlobalScopes(options, allowProject) {
-  if (!allowProject && options.project) throw new Error("--project/-p is only supported for `agent start`");
-  if (options.branch) throw new Error("--branch/-b is not supported for `agent`; pass --source explicitly");
-  if (options.session) throw new Error("--session/-s is not supported for `agent`; pass the session id explicitly");
+function requireModel(value) {
+  const model = requireValue(value?.trim(), "--model <tier> is required");
+  if (!MODEL_TIERS.has(model)) throw new Error("Invalid --model. Expected one of: low, medium, high, max");
+  return model;
+}
+function requireSessionMode(value) {
+  const mode = requireValue(value?.trim(), "--mode <mode> is required");
+  if (!R5DCTL_SESSION_MODES.has(mode)) {
+    throw new Error("Invalid --mode. Expected one of: ask, plan, build, agent");
+  }
+  return mode;
+}
+function rejectSessionRunGlobalScopes(options, allowProject) {
+  if (!allowProject && options.project) throw new Error("--project/-p is only supported for `session start`");
+  if (options.branch) throw new Error("--branch/-b is not supported for `session`; select the worktree explicitly");
+  if (options.session) throw new Error("--session/-s is not supported for `session`; pass the session id explicitly");
 }
-function parseBranchAgentCommand(options, args) {
-  const subcommand = requireValue(args[0], "Missing agent command");
+function parseSessionRunCommand(options, args) {
+  const subcommand = requireValue(args[0], "Missing session command");
   const commandArgs = args.slice(1);
   if (subcommand === "start") {
-    rejectAgentGlobalScopes(options, true);
-    const project = requireValue(options.project, "--project/-p is required for `agent start`");
-    const parsed = parseAgentOperands(commandArgs, /* @__PURE__ */ new Set(["--worker", "--source"]), { allowFlagLikeValuesAfter: 1 });
-    const agentType = requireValue(parsed.positionals[0], "Agent type is required for `agent start`");
-    if (!AGENT_TYPES.has(agentType)) {
-      throw new Error("Invalid agent type. Expected one of: research, debug, test");
-    }
-    const prompt = parsed.positionals.slice(1).join(" ").trim();
-    if (!prompt) throw new Error("Agent prompt is required for `agent start`");
+    rejectSessionRunGlobalScopes(options, true);
+    const project = requireValue(options.project, "--project/-p is required for `session start`");
+    const parsed = parseCommandOperands(
+      commandArgs,
+      /* @__PURE__ */ new Set(["--worker", "--worktree", "--new-worktree", "--source", "--model"]),
+      /* @__PURE__ */ new Map([
+        ["-f", "--follow"],
+        ["--follow", "--follow"],
+        ["--watch", "--follow"],
+        ["--tools", "--tools"]
+      ]),
+      "session start",
+      1
+    );
+    const prompt = parsed.positionals.join(" ").trim();
+    if (!prompt) throw new Error("Prompt is required for `session start`");
+    const worktree = parsed.values.get("--worktree")?.trim();
+    const newWorktree = parsed.values.get("--new-worktree")?.trim();
+    if (Boolean(worktree) === Boolean(newWorktree)) {
+      throw new Error("Use exactly one of --worktree <branch> or --new-worktree <branch>");
+    }
+    const sourceValue = parsed.values.get("--source");
+    if (worktree && sourceValue) throw new Error("--source is only supported with --new-worktree");
     return {
       kind: "start",
       project,
-      worker: requireAgentWorker(parsed.values),
-      source: requireAgentSource(parsed.values),
-      agentType,
-      prompt
+      worker: requireWorker(parsed.values),
+      model: requireModel(parsed.values.get("--model")),
+      prompt,
+      follow: parsed.booleans.has("--follow"),
+      includeTools: parsed.booleans.has("--tools"),
+      ...worktree ? { worktree } : { newWorktree, source: parseWorktreeSource(sourceValue) }
     };
   }
-  rejectAgentGlobalScopes(options, false);
+  rejectSessionRunGlobalScopes(options, false);
   if (subcommand === "status" || subcommand === "stop") {
-    const parsed = parseAgentOperands(commandArgs, /* @__PURE__ */ new Set());
-    const sessionId = requireValue(parsed.positionals[0], `Session id is required for \`agent ${subcommand}\``);
-    if (parsed.positionals.length > 1) throw new Error(`Unexpected agent ${subcommand} argument: ${parsed.positionals[1]}`);
+    const parsed = parseCommandOperands(commandArgs, /* @__PURE__ */ new Set(), /* @__PURE__ */ new Map(), `session ${subcommand}`);
+    const sessionId = requireValue(parsed.positionals[0], `Session id is required for \`session ${subcommand}\``);
+    if (parsed.positionals.length > 1) throw new Error(`Unexpected session ${subcommand} argument: ${parsed.positionals[1]}`);
     return { kind: subcommand, sessionId };
   }
   if (subcommand === "prompt") {
-    const parsed = parseAgentOperands(commandArgs, /* @__PURE__ */ new Set(["--worker"]), { allowFlagLikeValuesAfter: 1 });
-    const sessionId = requireValue(parsed.positionals[0], "Session id is required for `agent prompt`");
+    const parsed = parseCommandOperands(commandArgs, /* @__PURE__ */ new Set(["--worker", "--mode", "--model"]), /* @__PURE__ */ new Map(), "session prompt", 1);
+    const sessionId = requireValue(parsed.positionals[0], "Session id is required for `session prompt`");
     const prompt = parsed.positionals.slice(1).join(" ").trim();
-    if (!prompt) throw new Error("Prompt is required for `agent prompt`");
-    return { kind: "prompt", worker: requireAgentWorker(parsed.values), sessionId, prompt };
+    if (!prompt) throw new Error("Prompt is required for `session prompt`");
+    return {
+      kind: "prompt",
+      worker: requireWorker(parsed.values),
+      sessionId,
+      prompt,
+      mode: requireSessionMode(parsed.values.get("--mode")),
+      model: requireModel(parsed.values.get("--model"))
+    };
   }
-  if (subcommand === "merge") {
-    const parsed = parseAgentOperands(commandArgs, /* @__PURE__ */ new Set(["--worker"]));
-    const sessionId = requireValue(parsed.positionals[0], "Session id is required for `agent merge`");
-    if (parsed.positionals.length > 1) throw new Error(`Unexpected agent merge argument: ${parsed.positionals[1]}`);
-    return { kind: "merge", worker: requireAgentWorker(parsed.values), sessionId };
+  throw new Error(`Unknown session command: ${subcommand}`);
+}
+function parseMergeCommand(options, args) {
+  const project = requireValue(options.project, "--project/-p is required for `merge`");
+  if (options.branch) throw new Error("--branch/-b is not supported for `merge`; pass the source worktree explicitly");
+  if (options.session) throw new Error("--session/-s is not supported for `merge`");
+  if (args[0] === "finish") {
+    const parsed2 = parseCommandOperands(args.slice(1), /* @__PURE__ */ new Set(["--worker", "--summary"]), /* @__PURE__ */ new Map(), "merge finish");
+    const conflictWorktree = requireValue(parsed2.positionals[0], "Conflict worktree is required for `merge finish`");
+    if (parsed2.positionals.length > 1) throw new Error(`Unexpected merge finish argument: ${parsed2.positionals[1]}`);
+    return {
+      kind: "finish",
+      project,
+      conflictWorktree,
+      worker: requireWorker(parsed2.values),
+      ...parsed2.values.get("--summary")?.trim() ? { summary: parsed2.values.get("--summary").trim() } : {}
+    };
   }
-  if (subcommand === "finish-merge") {
-    const parsed = parseAgentOperands(commandArgs, /* @__PURE__ */ new Set(["--worker", "--summary"]));
-    const resolverSessionId = requireValue(parsed.positionals[0], "Resolver session id is required for `agent finish-merge`");
-    if (parsed.positionals.length > 1) throw new Error(`Unexpected agent finish-merge argument: ${parsed.positionals[1]}`);
-    const summary = requireValue(parsed.values.get("--summary")?.trim(), "--summary <text> is required for `agent finish-merge`");
-    return { kind: "finish-merge", worker: requireAgentWorker(parsed.values), resolverSessionId, summary };
+  const parsed = parseCommandOperands(
+    args,
+    /* @__PURE__ */ new Set(["--worker"]),
+    /* @__PURE__ */ new Map([
+      ["--create-conflict-worktree", "--create-conflict-worktree"],
+      ["--launch-conflict-resolution-agent", "--launch-conflict-resolution-agent"]
+    ]),
+    "merge"
+  );
+  const sourceWorktree = requireValue(parsed.positionals[0], "Source worktree is required for `merge`");
+  if (parsed.positionals.length > 1) throw new Error(`Unexpected merge argument: ${parsed.positionals[1]}`);
+  const createWorktree = parsed.booleans.has("--create-conflict-worktree");
+  const launchAgent = parsed.booleans.has("--launch-conflict-resolution-agent");
+  if (createWorktree && launchAgent) {
+    throw new Error("Use only one of --create-conflict-worktree or --launch-conflict-resolution-agent");
   }
-  throw new Error(`Unknown agent command: ${subcommand}`);
+  const conflictMode = createWorktree ? "worktree" : launchAgent ? "agent" : "none";
+  const worker = parsed.values.get("--worker")?.trim();
+  return { kind: "merge", project, sourceWorktree, conflictMode, ...worker ? { worker } : {} };
 }
 function assertAuthLoginArgs(args) {
   const valueFlags = /* @__PURE__ */ new Set(["--device-name", "--worker-label"]);
@@ -806,6 +875,55 @@ function parseAnswerFlags(args) {
   }
   return ordered.map(([, value]) => value);
 }
+function requireChatMode(value) {
+  const mode = requireValue(value?.trim(), "--mode <mode> is required");
+  if (!CHAT_MODES.has(mode)) throw new Error(`Invalid --mode: ${mode}`);
+  return mode;
+}
+function partitionInteractiveExecutionArgs(args, consumesNextValue) {
+  const values = /* @__PURE__ */ new Map();
+  const payloadArgs = [];
+  const executionFlags = ["--worker", "--mode", "--model"];
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+    if (consumesNextValue(arg)) {
+      payloadArgs.push(arg);
+      const value = args[index + 1];
+      if (value === void 0) throw new Error(`Missing value for ${arg}`);
+      payloadArgs.push(value);
+      index += 1;
+      continue;
+    }
+    const inlineFlag = executionFlags.find((flag) => arg.startsWith(`${flag}=`));
+    if (inlineFlag) {
+      if (values.has(inlineFlag)) throw new Error(`${inlineFlag} may only be provided once`);
+      const value = requireValue(arg.slice(inlineFlag.length + 1).trim(), `Missing value for ${inlineFlag}`);
+      values.set(inlineFlag, value);
+      continue;
+    }
+    if (executionFlags.includes(arg)) {
+      const flag = arg;
+      if (values.has(flag)) throw new Error(`${flag} may only be provided once`);
+      const value = requireValue(args[index + 1]?.trim(), `Missing value for ${flag}`);
+      values.set(flag, value);
+      index += 1;
+      continue;
+    }
+    payloadArgs.push(arg);
+  }
+  return {
+    context: {
+      worker: requireValue(values.get("--worker")?.trim(), "--worker <label> is required"),
+      mode: requireChatMode(values.get("--mode")),
+      model: requireModel(values.get("--model"))
+    },
+    payloadArgs
+  };
+}
+function parseAnswerQuestionsCommandArgs(args) {
+  const { context, payloadArgs } = partitionInteractiveExecutionArgs(args, (arg) => /^-a\d+$/.test(arg));
+  return { ...context, answers: parseAnswerFlags(payloadArgs) };
+}
 function validateEnvAssignment(value) {
   const equalsIndex = value.indexOf("=");
   if (equalsIndex <= 0) {
@@ -965,6 +1083,10 @@ function parseEnvRequestResponseArgs(args) {
     ...additionalContext?.trim() ? { additionalContext: additionalContext.trim() } : {}
   };
 }
+function parseAnswerEnvRequestCommandArgs(args) {
+  const { context, payloadArgs } = partitionInteractiveExecutionArgs(args, (arg) => arg === "-e" || arg === "--env" || arg === "--context");
+  return { ...context, ...parseEnvRequestResponseArgs(payloadArgs) };
+}
 function parsePromptArgs(args) {
   let modeRaw;
   let modelRaw;
@@ -1739,11 +1861,6 @@ function responseString(response, key) {
   const value = response[key];
   return typeof value === "string" && value.length > 0 ? value : void 0;
 }
-function responseSource(response) {
-  const source = response.source;
-  if (!source || source.type !== "worktree" || !source.branchName) return void 0;
-  return `${source.type}:${source.branchName}`;
-}
 function formatStatusValue(value) {
   if (typeof value === "string" && value.length > 0) return value;
   if (typeof value === "object" && value !== null) {
@@ -1753,21 +1870,16 @@ function formatStatusValue(value) {
   }
   return value === void 0 || value === null ? void 0 : String(value);
 }
-function asResponseRecord(value) {
-  return typeof value === "object" && value !== null ? value : void 0;
-}
-function appendMergeDetails(lines, response) {
-  const merge = asResponseRecord(response.merge);
-  if (!merge) return;
+function appendMergeDetails(lines, merge) {
   const mergeStatus = formatStatusValue(merge.status);
-  lines.push("", `Merge: ${mergeStatus ?? "pending"}`);
+  lines.push(`Merge: ${mergeStatus ?? "pending"}`);
   for (const [label, key] of [
     ["Attempt", "attemptId"],
-    ["Source", "sourceBranch"],
-    ["Target", "targetBranch"],
+    ["Source worktree", "sourceWorktree"],
+    ["Target worktree", "targetWorktree"],
     ["Commit", "commitHash"],
     ["Resolver agent", "resolverSessionId"],
-    ["Resolver branch", "resolverBranch"],
+    ["Conflict worktree", "conflictWorktree"],
     ["Resolver worktree", "folderPath"]
   ]) {
     const value = responseString(merge, key);
@@ -1781,45 +1893,30 @@ function appendMergeDetails(lines, response) {
   if (message) lines.push("", message);
   const failureReason = responseString(merge, "failureReason");
   if (failureReason) lines.push(`Failure: ${failureReason}`);
-  const resolverSessionId = responseString(merge, "resolverSessionId");
-  const worker = responseString(merge, "worker") ?? responseString(response, "worker");
-  if (resolverSessionId && worker) {
-    lines.push(
-      "",
-      "Resolver takeover:",
-      `  r5dctl agent stop ${resolverSessionId}`,
-      `  r5dctl agent finish-merge --worker ${worker} ${resolverSessionId} --summary "<summary>"`
-    );
-  }
 }
-function renderBranchAgentStart(agent) {
+function renderSessionRunStart(session) {
   const lines = [
-    `Agent: ${responseString(agent, "sessionId") ?? "(unknown)"}`,
-    `Status: ${formatStatusValue(agent.status) ?? "queued"}`,
-    `Branch: ${responseString(agent, "branchName") ?? "(provisioning)"}`,
-    `Source: ${responseSource(agent) ?? "(unknown)"}`,
-    `Workspace head: ${responseString(agent, "workspaceHead") ?? "(pending)"}`,
-    `Baseline: ${responseString(agent, "baselineCommit") ?? "(pending)"}`,
-    `Worker: ${responseString(agent, "worker") ?? "(unassigned)"}`
+    `Session: ${responseString(session, "sessionId") ?? "(unknown)"}`,
+    `Status: ${formatStatusValue(session.status) ?? "queued"}`,
+    `Worktree: ${responseString(session, "branchName") ?? "(provisioning)"}`,
+    `Worker: ${responseString(session, "worker") ?? "(unassigned)"}`
   ];
-  const sessionUrl = responseString(agent, "sessionUrl");
-  if (sessionUrl) lines.push(`Session: ${sessionUrl}`);
-  const sessionId = responseString(agent, "sessionId");
-  if (sessionId) lines.push("", `Next: r5dctl agent status ${sessionId}`);
+  const sessionUrl = responseString(session, "sessionUrl");
+  if (sessionUrl) lines.push(`URL: ${sessionUrl}`);
+  const sessionId = responseString(session, "sessionId");
+  if (sessionId) lines.push("", `Next: r5dctl session status ${sessionId}`);
   return `${lines.join("\n")}
 `;
 }
-function renderBranchAgentStatus(agent) {
-  const status = formatStatusValue(agent.status) ?? "unknown";
-  const lines = [`Agent: ${responseString(agent, "sessionId") ?? "(unknown)"}`, `Status: ${status}`];
-  const runStatus = formatStatusValue(agent.runStatus);
+function renderSessionRunStatus(session) {
+  const status = formatStatusValue(session.status) ?? "unknown";
+  const lines = [`Session: ${responseString(session, "sessionId") ?? "(unknown)"}`, `Status: ${status}`];
+  const runStatus = formatStatusValue(session.runStatus);
   if (runStatus) lines.push(`Run: ${runStatus}`);
-  const promptDisposition = responseString(agent, "promptDisposition");
+  const promptDisposition = responseString(session, "promptDisposition");
   if (promptDisposition) lines.push(`Prompt: ${promptDisposition}`);
-  const branch = responseString(agent, "branchName");
-  if (branch) lines.push(`Branch: ${branch}`);
-  const source = responseSource(agent);
-  if (source) lines.push(`Source: ${source}`);
+  const branch = responseString(session, "branchName");
+  if (branch) lines.push(`Worktree: ${branch}`);
   for (const [label, key] of [
     ["Workspace head", "workspaceHead"],
     ["Baseline", "baselineCommit"],
@@ -1827,72 +1924,90 @@ function renderBranchAgentStatus(agent) {
     ["Worker", "worker"],
     ["Session", "sessionUrl"]
   ]) {
-    const value = responseString(agent, key);
+    const value = responseString(session, key);
     if (value) lines.push(`${label}: ${value}`);
   }
-  const error = responseString(agent, "error");
+  const error = responseString(session, "error");
   if (error) lines.push(`Error: ${error}`);
-  const headCommitError = responseString(agent, "headCommitError");
+  const headCommitError = responseString(session, "headCommitError");
   if (headCommitError) lines.push(`Head error: ${headCommitError}`);
-  const diffSummary = responseString(agent, "diffSummary");
+  const diffSummary = responseString(session, "diffSummary");
   if (diffSummary) lines.push("", diffSummary);
-  const summary = responseString(agent, "summary");
+  const summary = responseString(session, "summary");
   if (summary) lines.push("", summary);
-  appendMergeDetails(lines, agent);
-  const sessionId = responseString(agent, "sessionId");
-  if (sessionId && !asResponseRecord(agent.merge)) {
-    if (["provisioning", "queued", "running"].includes(status)) {
-      lines.push("", "Next:", `  r5dctl agent status ${sessionId}`, `  r5dctl agent stop ${sessionId}`);
-    } else if (["completed", "failed", "stopped"].includes(status)) {
-      const worker = responseString(agent, "worker") ?? "<worker>";
-      lines.push("", "Next:", `  r5dctl agent merge --worker ${worker} ${sessionId}`);
-    }
+  const sessionId = responseString(session, "sessionId");
+  if (sessionId && ["provisioning", "queued", "running"].includes(status)) {
+    lines.push("", "Next:", `  r5dctl session status ${sessionId}`, `  r5dctl session stop ${sessionId}`);
   }
   return `${lines.join("\n")}
 `;
 }
-function renderBranchAgentMerge(result) {
-  if (asResponseRecord(result.merge)) return renderBranchAgentStatus(result);
-  const wrapped = {
-    sessionId: result.sessionId,
-    status: result.status,
-    worker: result.worker,
-    merge: result
-  };
+function renderWorktreeMerge(result, input) {
   const lines = [];
-  appendMergeDetails(lines, wrapped);
-  return `${lines.slice(lines[0] === "" ? 1 : 0).join("\n")}
+  appendMergeDetails(lines, result);
+  const conflictWorktree = responseString(result, "conflictWorktree");
+  const resolverSessionId = responseString(result, "resolverSessionId");
+  const worker = responseString(result, "worker") ?? input.worker;
+  if (resolverSessionId) lines.push("", `Resolver session: ${resolverSessionId}`, `  r5dctl session stop ${resolverSessionId}`);
+  if (conflictWorktree && worker && ["conflicts", "conflict_worktree_created", "resolving"].includes(responseString(result, "status") ?? "")) {
+    lines.push(
+      "",
+      "Finish after resolving and reviewing the conflict worktree:",
+      `  r5dctl -p ${input.project} merge finish --worker ${worker} ${conflictWorktree} --summary "<summary>"`
+    );
+  }
+  return `${lines.join("\n")}
 `;
 }
-async function dispatchBranchAgentCommand(client, command) {
+async function dispatchSessionRunCommand(client, command) {
   if (command.kind === "start") {
-    const data2 = await client.projects.agents.start(command.project, {
-      source: command.source,
-      agentType: command.agentType,
+    const commonInput = {
       prompt: command.prompt,
       worker: command.worker,
+      model: command.model,
       requestId: (0, import_node_crypto.randomUUID)()
-    });
-    return { data: data2, human: renderBranchAgentStart(data2) };
+    };
+    let input;
+    if (command.worktree !== void 0) {
+      input = { ...commonInput, worktree: command.worktree };
+    } else if (command.newWorktree !== void 0 && command.source !== void 0) {
+      input = { ...commonInput, newWorktree: command.newWorktree, source: command.source };
+    } else {
+      throw new Error("Session start requires an existing or new worktree");
+    }
+    const data2 = await client.projects.sessions.start(command.project, input);
+    return { data: data2, human: renderSessionRunStart(data2) };
   }
   if (command.kind === "status") {
-    const data2 = await client.agents.status(command.sessionId);
-    return { data: data2, human: renderBranchAgentStatus(data2) };
+    const data2 = await client.sessions.status(command.sessionId);
+    return { data: data2, human: renderSessionRunStatus(data2) };
   }
   if (command.kind === "prompt") {
-    const data2 = await client.agents.sendPrompt(command.sessionId, { prompt: command.prompt, worker: command.worker });
-    return { data: data2, human: renderBranchAgentStatus(data2) };
+    const data2 = await client.sessions.prompt(command.sessionId, {
+      prompt: command.prompt,
+      worker: command.worker,
+      mode: command.mode,
+      model: command.model,
+      requestId: (0, import_node_crypto.randomUUID)()
+    });
+    return { data: data2, human: renderSessionRunStatus(data2) };
   }
+  const data = await client.sessions.stop(command.sessionId);
+  return { data, human: renderSessionRunStatus(data) };
+}
+async function dispatchMergeCommand(client, command) {
   if (command.kind === "merge") {
-    const data2 = await client.agents.merge(command.sessionId, { worker: command.worker });
-    return { data: data2, human: renderBranchAgentMerge(data2) };
-  }
-  if (command.kind === "stop") {
-    const data2 = await client.agents.stop(command.sessionId);
-    return { data: data2, human: renderBranchAgentStatus(data2) };
+    const data2 = await client.projects.worktrees.merge(command.project, command.sourceWorktree, {
+      conflictMode: command.conflictMode,
+      ...command.worker ? { worker: command.worker } : {}
+    });
+    return { data: data2, human: renderWorktreeMerge(data2, command) };
   }
-  const data = await client.agents.finishMerge(command.resolverSessionId, { worker: command.worker, summary: command.summary });
-  return { data, human: renderBranchAgentMerge(data) };
+  const data = await client.projects.worktrees.finishMerge(command.project, command.conflictWorktree, {
+    worker: command.worker,
+    ...command.summary ? { summary: command.summary } : {}
+  });
+  return { data, human: renderWorktreeMerge(data, command) };
 }
 function parseProjectUpdateArgs(args) {
   const input = {};
@@ -1967,7 +2082,7 @@ function parseSessionUpdateArgs(args) {
   return input;
 }
 function parseConversationRenderArgs(args) {
-  const options = { format: "human", includeTools: false, includeSystem: false };
+  const options = { format: "human", includeTools: false, includeSystem: false, follow: false };
   for (const arg of args) {
     if (arg === "--raw") {
       options.format = "raw";
@@ -1981,6 +2096,11 @@ function parseConversationRenderArgs(args) {
       options.includeSystem = true;
       continue;
     }
+    if (arg === "-f" || arg === "--follow" || arg === "--watch") {
+      if (options.follow) throw new Error("--follow may only be provided once");
+      options.follow = true;
+      continue;
+    }
     throw new Error(`Unknown conversation argument: ${arg}`);
   }
   return options;
@@ -1989,6 +2109,306 @@ function renderConversationResponse(read) {
   return read.agentText.endsWith("\n") ? read.agentText : `${read.agentText}
 `;
 }
+function recordValue(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : null;
+}
+function nodeId(node) {
+  const id = recordValue(node)?.id;
+  return typeof id === "string" && id.length > 0 ? id : void 0;
+}
+function nodeType(node) {
+  const type = recordValue(node)?.type;
+  return typeof type === "string" ? type : void 0;
+}
+function assistantNodeText(node) {
+  const record = recordValue(node);
+  return record?.type === "assistant_message" && typeof record.content === "string" ? record.content : void 0;
+}
+function conversationRevision(read) {
+  const revision = recordValue(read.conversation)?.revision;
+  return typeof revision === "number" ? revision : 0;
+}
+function activeConversationNodes(conversation) {
+  const record = recordValue(conversation);
+  const responses = recordValue(record?.responses);
+  let currentId = typeof record?.head === "string" ? record.head : "";
+  if (!responses || !currentId) return [];
+  const reversed = [];
+  const visited = /* @__PURE__ */ new Set();
+  while (currentId && !visited.has(currentId)) {
+    visited.add(currentId);
+    const node = responses[currentId];
+    if (!node) break;
+    reversed.push(node);
+    const parent = recordValue(node)?.parent;
+    currentId = typeof parent === "string" ? parent : "";
+  }
+  return reversed.reverse();
+}
+function isToolEvent(event) {
+  return ["tool_use_start", "input_json_delta", "tool_call", "tool_progress", "shell_result"].includes(event.type);
+}
+function withoutToolDetails(node) {
+  const record = recordValue(node);
+  if (!record || record.type !== "assistant_message" || !Array.isArray(record.toolCalls)) return node;
+  return { ...record, toolCalls: [] };
+}
+function jsonConversationData(read, includeTools) {
+  if (includeTools) return read;
+  const { conversation: _conversation, thread, ...rest } = read;
+  return {
+    ...rest,
+    thread: Array.isArray(thread) ? thread.filter((node) => nodeType(node) !== "tool_result").map((node) => withoutToolDetails(node)) : []
+  };
+}
+function jsonFollowEvent(event, includeTools) {
+  if (event.type === "session") {
+    const data = recordValue(event.data);
+    if (!data) return event;
+    const { conversation: _conversation, ...rest } = data;
+    return { ...event, data: rest };
+  }
+  if (includeTools) return event;
+  if (isToolEvent(event)) return null;
+  if (event.type === "response") {
+    const data = recordValue(event.data);
+    const node = data?.node;
+    if (nodeType(node) === "tool_result") return null;
+    return { ...event, data: { ...data, node: withoutToolDetails(node) } };
+  }
+  return event;
+}
+function terminalRunStatus(response) {
+  const status = formatStatusValue(response.runStatus) ?? formatStatusValue(response.status);
+  return {
+    terminal: status !== void 0 && ["idle", "completed", "failed", "stopped"].includes(status),
+    failed: status === "failed"
+  };
+}
+function isAbortError(error) {
+  return error instanceof DOMException && error.name === "AbortError" || error instanceof Error && (error.name === "AbortError" || error.message.toLowerCase().includes("aborted"));
+}
+async function followR5dctlSession(client, sessionId, options) {
+  const writeOut = options.stdout ?? ((text) => process.stdout.write(text));
+  const writeErr = options.stderr ?? ((text) => process.stderr.write(text));
+  const seenNodeIds = /* @__PURE__ */ new Set();
+  let latestRevision = 0;
+  let streamedAssistantText = "";
+  let reconnects = 0;
+  const emitJson = (value) => writeOut(`${JSON.stringify(value)}
+`);
+  const renderNode = (node) => {
+    const id = nodeId(node);
+    if (id && seenNodeIds.has(id)) return;
+    if (id) seenNodeIds.add(id);
+    const text = assistantNodeText(node);
+    if (text !== void 0) {
+      let missing = text;
+      if (streamedAssistantText && text.startsWith(streamedAssistantText)) missing = text.slice(streamedAssistantText.length);
+      else if (streamedAssistantText.startsWith(text)) missing = "";
+      if (missing) writeOut(missing);
+      streamedAssistantText = "";
+      if (options.includeTools) {
+        const toolCalls = recordValue(node)?.toolCalls;
+        if (Array.isArray(toolCalls) && toolCalls.length > 0) writeErr(`[tools] ${JSON.stringify(toolCalls)}
+`);
+      }
+      return;
+    }
+    if (options.includeTools && nodeType(node) === "tool_result") writeErr(`[tool results] ${JSON.stringify(node)}
+`);
+  };
+  const syncConversation = async (initial = false) => {
+    const read = initial && options.initialConversation ? options.initialConversation : await client.sessions.conversation(sessionId, options.renderOptions);
+    const nodes = Array.isArray(read.thread) ? read.thread : [];
+    const newNodes = nodes.filter((node) => {
+      const id = nodeId(node);
+      return !id || !seenNodeIds.has(id);
+    });
+    if (initial && options.printInitialTranscript) {
+      if (options.json)
+        emitJson({ type: "conversation", revision: conversationRevision(read), data: jsonConversationData(read, options.includeTools) });
+      else writeOut(renderConversationResponse(read));
+      for (const node of nodes) {
+        const id = nodeId(node);
+        if (id) seenNodeIds.add(id);
+      }
+    } else if (options.json && newNodes.length > 0) {
+      const filtered = options.includeTools ? newNodes : newNodes.filter((node) => nodeType(node) !== "tool_result");
+      if (filtered.length > 0) {
+        emitJson({
+          type: "conversation_sync",
+          revision: conversationRevision(read),
+          nodes: options.includeTools ? filtered : filtered.map((node) => withoutToolDetails(node))
+        });
+      }
+      for (const node of newNodes) {
+        const id = nodeId(node);
+        if (id) seenNodeIds.add(id);
+      }
+    } else {
+      for (const node of newNodes) renderNode(node);
+    }
+    latestRevision = Math.max(latestRevision, conversationRevision(read));
+    return read;
+  };
+  await syncConversation(true);
+  while (!options.signal?.aborted) {
+    try {
+      for await (const event of client.sessions.events(sessionId, { signal: options.signal })) {
+        reconnects = 0;
+        if (event.type === "response") {
+          const data = recordValue(event.data);
+          const revision = data?.conversationRevision;
+          const id = nodeId(data?.node);
+          if (typeof revision === "number" && revision <= latestRevision || id !== void 0 && seenNodeIds.has(id)) continue;
+        }
+        if (options.json) {
+          const outputEvent = jsonFollowEvent(event, options.includeTools);
+          if (outputEvent) emitJson(outputEvent);
+        } else if (event.type === "text_delta" && typeof event.text === "string") {
+          writeOut(event.text);
+          streamedAssistantText += event.text;
+        } else if (event.type === "thinking_delta" && typeof event.text === "string") {
+          writeErr(event.text);
+        } else if (event.type === "tool_use_start" && options.includeTools) {
+          writeErr(`[tool] ${String(event.toolName)}
+`);
+        } else if (event.type === "input_json_delta" && options.includeTools) {
+          writeErr(String(event.partial_json));
+        } else if ((event.type === "tool_call" || event.type === "tool_progress" || event.type === "shell_result") && options.includeTools) {
+          writeErr(`[${event.type}] ${JSON.stringify(event)}
+`);
+        } else if (event.type === "status") {
+          writeErr(`[status] ${formatStatusValue(event.status) ?? "updated"}
+`);
+        } else if (event.type === "agent_running") {
+          writeErr(`[running] ${event.running ? "yes" : "no"}
+`);
+        } else if (event.type === "stream_reset") {
+          streamedAssistantText = "";
+          writeErr(`[retry] ${event.attempt}/${event.maxAttempts}
+`);
+        } else if (event.type === "response") {
+          const revision = recordValue(event.data)?.conversationRevision;
+          if (typeof revision === "number") latestRevision = revision;
+          renderNode(recordValue(event.data)?.node);
+        } else if (event.type === "session") {
+          const session = recordValue(event.data);
+          const conversation = session?.conversation;
+          for (const node of activeConversationNodes(conversation)) renderNode(node);
+          const revision = recordValue(conversation)?.revision;
+          if (typeof revision === "number") latestRevision = Math.max(latestRevision, revision);
+          const streamingText = recordValue(session?.streaming)?.text;
+          if (!options.json && typeof streamingText === "string" && streamingText.length > 0) {
+            let missing = streamingText;
+            if (streamedAssistantText && streamingText.startsWith(streamedAssistantText))
+              missing = streamingText.slice(streamedAssistantText.length);
+            else if (streamedAssistantText.startsWith(streamingText)) missing = "";
+            if (missing) writeOut(missing);
+            streamedAssistantText = streamingText;
+          }
+          if (session?.agentRunning === false) {
+            try {
+              const terminal = terminalRunStatus(await client.sessions.status(sessionId));
+              if (terminal.terminal) return terminal.failed ? 1 : 0;
+            } catch (error) {
+              if (error instanceof import_r5d_api.R5dctlApiError && [401, 403, 404].includes(error.status)) throw error;
+              const status = formatStatusValue(session.status);
+              if (error instanceof import_r5d_api.R5dctlApiError && error.status === 400 && status === "idle") return 0;
+              if (error instanceof import_r5d_api.R5dctlApiError && error.status === 400 && status === "error") return 1;
+            }
+          }
+        }
+        if (event.type === "response" && options.json) {
+          const revision = recordValue(event.data)?.conversationRevision;
+          if (typeof revision === "number") latestRevision = Math.max(latestRevision, revision);
+          const id = nodeId(recordValue(event.data)?.node);
+          if (id) seenNodeIds.add(id);
+        }
+        if (event.type === "session" && options.json) {
+          const session = recordValue(event.data);
+          const conversation = session?.conversation;
+          const newNodes = activeConversationNodes(conversation).filter((node) => {
+            const id = nodeId(node);
+            return !id || !seenNodeIds.has(id);
+          });
+          const filteredNodes = options.includeTools ? newNodes : newNodes.filter((node) => nodeType(node) !== "tool_result");
+          if (filteredNodes.length > 0) {
+            emitJson({
+              type: "conversation_sync",
+              revision: recordValue(conversation)?.revision,
+              nodes: options.includeTools ? filteredNodes : filteredNodes.map((node) => withoutToolDetails(node))
+            });
+          }
+          for (const node of newNodes) {
+            const id = nodeId(node);
+            if (id) seenNodeIds.add(id);
+          }
+          const revision = recordValue(conversation)?.revision;
+          if (typeof revision === "number") latestRevision = Math.max(latestRevision, revision);
+          if (session?.agentRunning === false) {
+            try {
+              const terminal = terminalRunStatus(await client.sessions.status(sessionId));
+              if (terminal.terminal) return terminal.failed ? 1 : 0;
+            } catch (error) {
+              if (error instanceof import_r5d_api.R5dctlApiError && [401, 403, 404].includes(error.status)) throw error;
+              const status = formatStatusValue(session.status);
+              if (error instanceof import_r5d_api.R5dctlApiError && error.status === 400 && status === "idle") return 0;
+              if (error instanceof import_r5d_api.R5dctlApiError && error.status === 400 && status === "error") return 1;
+            }
+          }
+        }
+        if (event.type === "done" || event.type === "stopped") {
+          await syncConversation();
+          if (!options.json) writeErr(`[${event.type}]
+`);
+          try {
+            const terminal = terminalRunStatus(await client.sessions.status(sessionId));
+            if (terminal.terminal) return terminal.failed ? 1 : 0;
+            if (event.type === "done") continue;
+            return 0;
+          } catch (error) {
+            if (error instanceof import_r5d_api.R5dctlApiError && [401, 403, 404].includes(error.status)) throw error;
+            if (error instanceof import_r5d_api.R5dctlApiError && error.status === 400) return 0;
+            throw error;
+          }
+        }
+        if (event.type === "error") {
+          if (!options.json) writeErr(`${typeof event.message === "string" ? event.message : "Session failed"}
+`);
+          return 1;
+        }
+      }
+    } catch (error) {
+      if (options.signal?.aborted || isAbortError(error)) return 0;
+      if (error instanceof import_r5d_api.R5dctlApiError && [401, 403, 404].includes(error.status)) throw error;
+    }
+    if (options.signal?.aborted) return 0;
+    try {
+      await syncConversation();
+    } catch (error) {
+      if (error instanceof import_r5d_api.R5dctlApiError && [401, 403, 404].includes(error.status)) throw error;
+    }
+    try {
+      const terminal = terminalRunStatus(await client.sessions.status(sessionId));
+      if (terminal.terminal) return terminal.failed ? 1 : 0;
+    } catch (error) {
+      if (error instanceof import_r5d_api.R5dctlApiError && [401, 403, 404].includes(error.status)) throw error;
+    }
+    reconnects += 1;
+    if (reconnects > (options.maxReconnects ?? Number.POSITIVE_INFINITY)) {
+      throw new Error("Session event stream ended before the session became idle");
+    }
+    try {
+      await (0, import_promises.setTimeout)(options.reconnectDelayMs ?? Math.min(250 * 2 ** (reconnects - 1), 5e3), void 0, { signal: options.signal });
+    } catch (error) {
+      if (options.signal?.aborted || isAbortError(error)) return 0;
+      throw error;
+    }
+  }
+  return 0;
+}
 function parseConversationWorkDetailArgs(args) {
   let detail = "compact";
   let selected = false;
@@ -2220,8 +2640,8 @@ Sessions: ${result.sessions.length}
       throw new Error(`Unexpected conversation inspect-node argument: ${args[4]}`);
     }
     const sessionId = requireValue(args[2], "Missing session id");
-    const nodeId = requireValue(args[3], "Missing node id");
-    const read = await client.sessions.inspectConversationNode(sessionId, nodeId);
+    const nodeId2 = requireValue(args[3], "Missing node id");
+    const read = await client.sessions.inspectConversationNode(sessionId, nodeId2);
     write(read, renderConversationNodeResponse(read));
     return;
   }
@@ -2236,33 +2656,30 @@ Sessions: ${result.sessions.length}
   if (first === "sessions" && second === "conversation" || first === "conversation") {
     const offset = first === "conversation" ? 1 : 2;
     const renderOptions = parseConversationRenderArgs(args.slice(offset + 1));
-    const read = await client.sessions.conversation(requireValue(args[offset], "Missing session id"), renderOptions);
-    write(read, renderConversationResponse(read));
-    return;
-  }
-  if (first === "sessions" && second === "prompt" || first === "prompt") {
-    const offset = first === "prompt" ? 1 : 2;
-    const read = await client.sessions.prompt(requireValue(args[offset], "Missing session id"), {
-      mode: requireValue(args[offset + 1], "Missing mode"),
-      model: requireValue(args[offset + 2], "Missing model"),
-      message: requireValue(args[offset + 3], "Missing prompt message")
-    });
+    if (renderOptions.follow) throw new Error("Conversation follow must be handled by the CLI stream runner");
+    const { follow: _follow, ...apiRenderOptions } = renderOptions;
+    const read = await client.sessions.conversation(requireValue(args[offset], "Missing session id"), apiRenderOptions);
     write(read, renderConversationResponse(read));
     return;
   }
   if (first === "sessions" && second === "answer-questions" || first === "answer-questions") {
     const offset = first === "answer-questions" ? 1 : 2;
-    const answers = args.slice(offset + 1);
-    if (answers.length === 0) throw new Error("At least one answer is required");
-    const read = await client.sessions.answerQuestions(requireValue(args[offset], "Missing session id"), { answers });
-    write(read, renderConversationResponse(read));
+    const input = parseAnswerQuestionsCommandArgs(args.slice(offset + 1));
+    const read = await client.sessions.answerQuestions(requireValue(args[offset], "Missing session id"), {
+      ...input,
+      requestId: (0, import_node_crypto.randomUUID)()
+    });
+    write(read, renderSessionRunStatus(read));
     return;
   }
   if (first === "sessions" && second === "answer-env-request" || first === "answer-env-request") {
     const offset = first === "answer-env-request" ? 1 : 2;
-    const input = parseEnvRequestResponseArgs(args.slice(offset + 1));
-    const read = await client.sessions.answerEnvRequest(requireValue(args[offset], "Missing session id"), input);
-    write(read, renderConversationResponse(read));
+    const input = parseAnswerEnvRequestCommandArgs(args.slice(offset + 1));
+    const read = await client.sessions.answerEnvRequest(requireValue(args[offset], "Missing session id"), {
+      ...input,
+      requestId: (0, import_node_crypto.randomUUID)()
+    });
+    write(read, renderSessionRunStatus(read));
     return;
   }
   throw new Error(`Unknown command: ${args.join(" ")}`);
@@ -2287,10 +2704,16 @@ function resolveCommandExecution(options, rest) {
       text: K8S_HELP_TEXT
     };
   }
-  if (command === "agent" && commandArgs.length === 0) {
+  if (command === "session" && commandArgs.length === 0) {
+    return {
+      kind: "cli-help",
+      text: SESSION_RUN_HELP_TEXT
+    };
+  }
+  if (command === "merge" && commandArgs.length === 0) {
     return {
       kind: "cli-help",
-      text: AGENT_HELP_TEXT
+      text: MERGE_HELP_TEXT
     };
   }
   if (trailingHelp) {
@@ -2652,24 +3075,23 @@ function resolveCommandExecution(options, rest) {
       if (!sessionId2) {
         throw new Error("Session id is required for `conversation inspect-node`");
       }
-      const nodeId = options.session ? commandArgs[1] : commandArgs[2];
-      if (!nodeId) {
+      const nodeId2 = options.session ? commandArgs[1] : commandArgs[2];
+      if (!nodeId2) {
         throw new Error("Node id is required for `conversation inspect-node`");
       }
       const remainingArgs = options.session ? commandArgs.slice(2) : commandArgs.slice(3);
       return {
         kind: "plugin",
-        pluginArgs: ["conversation", "inspect-node", sessionId2, nodeId, ...remainingArgs]
+        pluginArgs: ["conversation", "inspect-node", sessionId2, nodeId2, ...remainingArgs]
       };
     }
     const sessionId = options.session;
     if (!sessionId) {
       throw new Error("--session/-s is required for `conversation`");
     }
-    return {
-      kind: "plugin",
-      pluginArgs: ["conversation", sessionId, ...commandArgs]
-    };
+    const renderOptions = parseConversationRenderArgs(commandArgs);
+    if (renderOptions.follow) return { kind: "conversation-follow", sessionId, renderOptions };
+    return { kind: "plugin", pluginArgs: ["conversation", sessionId, ...commandArgs] };
   }
   if (command === "shell") {
     if (!options.project) {
@@ -2686,19 +3108,11 @@ function resolveCommandExecution(options, rest) {
       ...parseShellArgs(commandArgs)
     };
   }
-  if (command === "prompt") {
-    const sessionId = options.session;
-    if (!sessionId) {
-      throw new Error("--session/-s is required for `prompt`");
-    }
-    const parsed = parsePromptArgs(commandArgs);
-    return {
-      kind: "plugin",
-      pluginArgs: ["prompt", sessionId, parsed.mode, parsed.model, parsed.message]
-    };
+  if (command === "session") {
+    return { kind: "session-run", command: parseSessionRunCommand(options, commandArgs) };
   }
-  if (command === "agent") {
-    return { kind: "agent", command: parseBranchAgentCommand(options, commandArgs) };
+  if (command === "merge") {
+    return { kind: "merge", command: parseMergeCommand(options, commandArgs) };
   }
   if (command === "answer-questions") {
     const sessionId = options.session;
@@ -2707,7 +3121,7 @@ function resolveCommandExecution(options, rest) {
     }
     return {
       kind: "plugin",
-      pluginArgs: ["answer-questions", sessionId, ...parseAnswerFlags(commandArgs)]
+      pluginArgs: ["answer-questions", sessionId, ...commandArgs]
     };
   }
   if (command === "answer-env-request") {
@@ -2722,6 +3136,16 @@ function resolveCommandExecution(options, rest) {
   }
   throw new Error(`Unknown command: ${command}`);
 }
+async function followWithInterrupt(client, sessionId, options) {
+  const controller = new AbortController();
+  const detach = () => controller.abort();
+  process.once("SIGINT", detach);
+  try {
+    return await followR5dctlSession(client, sessionId, { ...options, signal: controller.signal });
+  } finally {
+    process.removeListener("SIGINT", detach);
+  }
+}
 async function runCommand(argv) {
   const { options, rest } = parseGlobalArgs(argv);
   if (options.version) {
@@ -2748,11 +3172,38 @@ async function runCommand(argv) {
     process.stdout.write(execution.text);
     return 0;
   }
-  if (execution.kind === "agent") {
-    const result = await dispatchBranchAgentCommand(client, execution.command);
+  if (execution.kind === "session-run") {
+    const result = await dispatchSessionRunCommand(client, execution.command);
+    if (execution.command.kind !== "start" || !execution.command.follow) {
+      writeDataOutput(options.json, result.data, result.human);
+      return 0;
+    }
+    const sessionId = requireValue(responseString(result.data, "sessionId"), "Session start did not return a session id");
+    if (options.json) process.stdout.write(`${JSON.stringify({ type: "session_started", data: result.data })}
+`);
+    else process.stderr.write(result.human);
+    return await followWithInterrupt(client, sessionId, {
+      json: options.json,
+      includeTools: execution.command.includeTools,
+      printInitialTranscript: false
+    });
+  }
+  if (execution.kind === "merge") {
+    const result = await dispatchMergeCommand(client, execution.command);
     writeDataOutput(options.json, result.data, result.human);
     return 0;
   }
+  if (execution.kind === "conversation-follow") {
+    const { follow: _follow, ...renderOptions } = execution.renderOptions;
+    const initialConversation = await client.sessions.conversation(execution.sessionId, renderOptions);
+    return await followWithInterrupt(client, execution.sessionId, {
+      json: options.json,
+      includeTools: execution.renderOptions.includeTools,
+      renderOptions,
+      initialConversation,
+      printInitialTranscript: true
+    });
+  }
   if (execution.kind === "shell") {
     const project = await client.projects.describe(options.project);
     return await (0, import_shell.runR5dctlShell)({
@@ -2802,7 +3253,9 @@ async function main(argv = process.argv.slice(2)) {
 0 && (module.exports = {
   advanceTransientDevicePollBackoff,
   collectK8sUsage,
-  dispatchBranchAgentCommand,
+  dispatchMergeCommand,
+  dispatchSessionRunCommand,
+  followR5dctlSession,
   formatK8sCpu,
   formatK8sMemory,
   formatProcessAge,
@@ -2813,8 +3266,9 @@ async function main(argv = process.argv.slice(2)) {
   getTransientDevicePollDelay,
   handleAuthLogin,
   main,
+  parseAnswerEnvRequestCommandArgs,
   parseAnswerFlags,
-  parseBranchAgentCommand,
+  parseAnswerQuestionsCommandArgs,
   parseConversationRenderArgs,
   parseConversationWorkDetailArgs,
   parseEnvFlags,
@@ -2822,15 +3276,14 @@ async function main(argv = process.argv.slice(2)) {
   parseGetEnvsArgs,
   parseGlobalArgs,
   parseK8sUsageArgs,
+  parseMergeCommand,
   parsePromptArgs,
   parsePsHistoryArgs,
   parsePsListArgs,
+  parseSessionRunCommand,
   parseSetEnvArgs,
   parseShellArgs,
   readDotenvFile,
-  renderBranchAgentMerge,
-  renderBranchAgentStart,
-  renderBranchAgentStatus,
   renderConversationNodeResponse,
   renderConversationOverviewResponse,
   renderConversationResponse,
@@ -2841,8 +3294,11 @@ async function main(argv = process.argv.slice(2)) {
   renderProcessHistory,
   renderProcessInspection,
   renderProcessList,
+  renderSessionRunStart,
+  renderSessionRunStatus,
   renderWorkspaceStatus,
   renderWorkspaceSync,
+  renderWorktreeMerge,
   resolveCommandExecution,
   runR5dctlCli,
   summarizeEnvData,