@ricsam/r5dctl 0.0.59 → 0.0.61

package/dist/mjs/cli.mjs

@@ -16,15 +16,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>",
@@ -78,6 +75,26 @@ const K8S_HELP_TEXT = [
   "Show current and rolling CPU and memory usage for managed-vCluster workload containers.",
   ""
 ].join("\n");
+const SESSION_RUN_HELP_TEXT = [
+  "Usage:",
+  '  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, 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 = [
   { section: "auth", usage: "auth status", description: "Show the current authenticated user and credential source." },
   { section: "auth", usage: "auth logout", description: "Revoke the current credential and clear saved auth." },
@@ -145,7 +162,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."
   },
   {
@@ -165,17 +182,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."
   },
   {
@@ -200,19 +232,15 @@ const SHARED_HELP_ENTRIES = [
   },
   { section: "processes", usage: "ps stop <run-id>", description: "Gracefully stop an active process with SIGTERM." },
   {
-    section: "agents",
-    usage: '-p <project> start-agent <src-branch> <agent-type> "<prompt>"',
-    description: "Start a detached branch agent."
+    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-status <session-id>", description: "Show detached branch agent status." },
-  { section: "agents", usage: 'send-prompt <session-id> "<prompt>"', description: "Queue or resume a detached branch agent." },
   {
-    section: "merges",
-    usage: "-p <project> merge-changes <target-branch> <sub-agent-branch>",
-    description: "Squash merge an agent branch into a target branch."
-  },
-  { section: "merges", usage: "-p <project> continue-merge <target-branch>", description: "Commit a resolved merge." },
-  { section: "merges", usage: "-p <project> abort-merge <target-branch>", description: "Abort an in-progress 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 = [
   "auth",
@@ -224,8 +252,7 @@ const HELP_SECTION_ORDER = [
   "kubernetes",
   "processes",
   "shell",
-  "agents",
-  "merges"
+  "merge"
 ];
 const HELP_SECTION_TITLES = {
   auth: "Auth",
@@ -237,8 +264,7 @@ const HELP_SECTION_TITLES = {
   kubernetes: "Kubernetes",
   processes: "Processes",
   shell: "Shell",
-  agents: "Agents",
-  merges: "Merges"
+  merge: "Worktree merging"
 };
 function getCliHelpText() {
   const entries = [...CLI_ONLY_HELP_ENTRIES, ...SHARED_HELP_ENTRIES];
@@ -337,7 +363,7 @@ function renderCliOnlyCommandHelp(entry) {
 function renderSharedCommandHelp(pathSegments) {
   const entry = SHARED_HELP_ENTRIES.map((candidate) => ({
     candidate,
-    usageSegments: candidate.usage.split(" ").map((segment) => segment.replace(/^\[/, "").replace(/\]$/, "")).filter((segment) => !segment.startsWith("-") && !segment.startsWith("<") && !segment.startsWith("["))
+    usageSegments: candidate.usage.split(" ").map((segment) => segment.replace(/^\[/, "").replace(/\]$/, "")).filter((segment) => !segment.startsWith("-") && !segment.includes("<") && !segment.startsWith("["))
   })).filter(
     ({ usageSegments }) => usageSegments.length <= pathSegments.length && usageSegments.every((segment, index) => segment === pathSegments[index])
   ).sort((left, right) => right.usageSegments.length - left.usageSegments.length)[0]?.candidate;
@@ -385,6 +411,173 @@ function parseOptionalFlagValue(args, flag, shortFlag) {
 function hasBooleanFlag(args, flag) {
   return args.includes(flag);
 }
+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];
+    if (parseOptions && arg === "--") {
+      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`);
+      const value = arg.slice(inlineFlag.length + 1).trim();
+      if (!value) throw new Error(`Missing value for ${inlineFlag}`);
+      values.set(inlineFlag, value);
+      continue;
+    }
+    if (parseOptions && valueFlags.has(arg)) {
+      if (values.has(arg)) throw new Error(`${arg} may only be provided once`);
+      const value = args[index + 1];
+      if (!value || value === "--" || valueFlags.has(value)) throw new Error(`Missing value for ${arg}`);
+      values.set(arg, value.trim());
+      index += 1;
+      continue;
+    }
+    if (parseOptions && arg.startsWith("-") && positionals.length < allowFlagLikeValuesAfter) {
+      throw new Error(`Unknown ${family} flag: ${arg}`);
+    }
+    positionals.push(arg);
+  }
+  return { positionals, values, booleans };
+}
+function requireWorker(values) {
+  return requireValue(values.get("--worker")?.trim(), "--worker <label> is required");
+}
+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();
+  if (type !== "worktree" || separator < 1 || !branchName) {
+    throw new Error("Invalid --source. Expected worktree:<branch>");
+  }
+  return { type, branchName };
+}
+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 parseSessionRunCommand(options, args) {
+  const subcommand = requireValue(args[0], "Missing session command");
+  const commandArgs = args.slice(1);
+  if (subcommand === "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: 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) }
+    };
+  }
+  rejectSessionRunGlobalScopes(options, false);
+  if (subcommand === "status" || subcommand === "stop") {
+    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 = 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 `session prompt`");
+    return {
+      kind: "prompt",
+      worker: requireWorker(parsed.values),
+      sessionId,
+      prompt,
+      mode: requireSessionMode(parsed.values.get("--mode")),
+      model: requireModel(parsed.values.get("--model"))
+    };
+  }
+  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() } : {}
+    };
+  }
+  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");
+  }
+  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"]);
   const booleanFlags = /* @__PURE__ */ new Set(["--no-open", "--no-qr"]);
@@ -601,6 +794,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) {
@@ -760,6 +1002,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;
@@ -1160,7 +1406,7 @@ function renderWorkspaceStatus(status) {
     `Remediation: ${status.incident ? `${status.incident.kind} ${status.incident.status} (${status.incident.id}) on ${status.incident.originWorkerLabel}` : "none"}`,
     `Materialization: ${status.materialization ? `${status.materialization.state}; ${status.materialization.materializedHead ?? "(none)"} -> ${status.materialization.desiredHead ?? "(none)"}; lag ${status.materialization.lagMs}ms` : "not initialized"}`,
     ...status.workers.map(
-      (worker) => `Worker ${worker.workerLabel}: ${worker.ready ? "ready" : "bootstrapping"}; ${worker.checkpointState}; head ${worker.localHead ?? "(none)"}; desired ${worker.desiredCanonicalHead ?? "(none)"}; generations ${worker.publishedGeneration}/${worker.dirtyGeneration}; pending checkouts ${worker.pendingCheckouts.length}; CAS retries ${worker.casRetries}; fan-out lag ${worker.fanoutLagMs ?? "unknown"}ms`
+      (worker) => `Worker ${worker.workerLabel}: ${worker.ready ? "ready" : "bootstrapping"}; publication ${worker.publicationState}; head ${worker.localHead ?? "(none)"}; desired ${worker.desiredCanonicalHead ?? "(none)"}; generations ${worker.publishedGeneration}/${worker.dirtyGeneration}; pending checkouts ${worker.pendingCheckouts.length}; CAS retries ${worker.casRetries}; fan-out lag ${worker.fanoutLagMs ?? "unknown"}ms`
     )
   ];
   return `${lines.join("\n")}
@@ -1530,44 +1776,158 @@ async function setProjectEnvs(client, projectRef, args) {
   }
   return result;
 }
-function renderAgentStart(agent) {
-  return [
-    `Agent: ${agent.sessionId}`,
-    `Status: ${agent.status}`,
-    `Branch: ${agent.branchName}`,
-    `Base: ${agent.baseBranch} @ ${agent.baseCommit}`
-  ].join("\n") + "\n";
+function responseString(response, key) {
+  const value = response[key];
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function formatStatusValue(value) {
+  if (typeof value === "string" && value.length > 0) return value;
+  if (typeof value === "object" && value !== null) {
+    const status = value.status;
+    if (typeof status === "string" && status.length > 0) return status;
+    return JSON.stringify(value);
+  }
+  return value === void 0 || value === null ? void 0 : String(value);
+}
+function appendMergeDetails(lines, merge) {
+  const mergeStatus = formatStatusValue(merge.status);
+  lines.push(`Merge: ${mergeStatus ?? "pending"}`);
+  for (const [label, key] of [
+    ["Attempt", "attemptId"],
+    ["Source worktree", "sourceWorktree"],
+    ["Target worktree", "targetWorktree"],
+    ["Commit", "commitHash"],
+    ["Resolver agent", "resolverSessionId"],
+    ["Conflict worktree", "conflictWorktree"],
+    ["Resolver worktree", "folderPath"]
+  ]) {
+    const value = responseString(merge, key);
+    if (value) lines.push(`${label}: ${value}`);
+  }
+  const conflictedFiles = Array.isArray(merge.conflictedFiles) ? merge.conflictedFiles.filter((file) => typeof file === "string") : [];
+  if (conflictedFiles.length > 0) {
+    lines.push("", "Conflicts:", ...conflictedFiles.map((file) => `- ${file}`));
+  }
+  const message = responseString(merge, "message");
+  if (message) lines.push("", message);
+  const failureReason = responseString(merge, "failureReason");
+  if (failureReason) lines.push(`Failure: ${failureReason}`);
+}
+function renderSessionRunStart(session) {
+  const lines = [
+    `Session: ${responseString(session, "sessionId") ?? "(unknown)"}`,
+    `Status: ${formatStatusValue(session.status) ?? "queued"}`,
+    `Worktree: ${responseString(session, "branchName") ?? "(provisioning)"}`,
+    `Worker: ${responseString(session, "worker") ?? "(unassigned)"}`
+  ];
+  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 renderAgentStatus(agent) {
-  const lines = [`Agent: ${agent.sessionId}`, `Status: ${agent.status}`, `Branch: ${agent.branchName}`, `Head: ${agent.headCommit}`];
-  if (agent.baseBranch && agent.baseCommit) {
-    lines.push(`Base: ${agent.baseBranch} @ ${agent.baseCommit}`);
-  }
-  if (agent.error) {
-    lines.push(`Error: ${agent.error}`);
-  }
-  if (agent.diffSummary) {
-    lines.push("", agent.diffSummary);
-  }
-  if (agent.summary) {
-    lines.push("", agent.summary);
+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(session, "promptDisposition");
+  if (promptDisposition) lines.push(`Prompt: ${promptDisposition}`);
+  const branch = responseString(session, "branchName");
+  if (branch) lines.push(`Worktree: ${branch}`);
+  for (const [label, key] of [
+    ["Workspace head", "workspaceHead"],
+    ["Baseline", "baselineCommit"],
+    ["Head", "headCommit"],
+    ["Worker", "worker"],
+    ["Session", "sessionUrl"]
+  ]) {
+    const value = responseString(session, key);
+    if (value) lines.push(`${label}: ${value}`);
+  }
+  const error = responseString(session, "error");
+  if (error) lines.push(`Error: ${error}`);
+  const headCommitError = responseString(session, "headCommitError");
+  if (headCommitError) lines.push(`Head error: ${headCommitError}`);
+  const diffSummary = responseString(session, "diffSummary");
+  if (diffSummary) lines.push("", diffSummary);
+  const summary = responseString(session, "summary");
+  if (summary) lines.push("", summary);
+  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 renderMergeResult(result) {
-  if (result.status === "merged") {
-    return `Merged ${result.sourceBranch} into ${result.targetBranch}: ${result.commitHash}
-${result.message}
-`;
+function renderWorktreeMerge(result, input) {
+  const lines = [];
+  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>"`
+    );
   }
-  const files = result.conflictedFiles.length > 0 ? `
-Conflicts:
-${result.conflictedFiles.map((file) => `- ${file}`).join("\n")}
-` : "\n";
-  return `Merge has conflicts from ${result.sourceBranch} into ${result.targetBranch}.${files}${result.message}
+  return `${lines.join("\n")}
 `;
 }
+async function dispatchSessionRunCommand(client, command) {
+  if (command.kind === "start") {
+    const commonInput = {
+      prompt: command.prompt,
+      worker: command.worker,
+      model: command.model,
+      requestId: randomUUID()
+    };
+    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.sessions.status(command.sessionId);
+    return { data: data2, human: renderSessionRunStatus(data2) };
+  }
+  if (command.kind === "prompt") {
+    const data2 = await client.sessions.prompt(command.sessionId, {
+      prompt: command.prompt,
+      worker: command.worker,
+      mode: command.mode,
+      model: command.model,
+      requestId: 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.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.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 = {};
   for (let index = 0; index < args.length; index += 1) {
@@ -1641,7 +2001,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";
@@ -1655,6 +2015,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;
@@ -1663,6 +2028,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 R5dctlApiError && [401, 403, 404].includes(error.status)) throw error;
+              const status = formatStatusValue(session.status);
+              if (error instanceof R5dctlApiError && error.status === 400 && status === "idle") return 0;
+              if (error instanceof 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 R5dctlApiError && [401, 403, 404].includes(error.status)) throw error;
+              const status = formatStatusValue(session.status);
+              if (error instanceof R5dctlApiError && error.status === 400 && status === "idle") return 0;
+              if (error instanceof 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 R5dctlApiError && [401, 403, 404].includes(error.status)) throw error;
+            if (error instanceof 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 R5dctlApiError && [401, 403, 404].includes(error.status)) throw error;
+    }
+    if (options.signal?.aborted) return 0;
+    try {
+      await syncConversation();
+    } catch (error) {
+      if (error instanceof 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 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 sleep(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;
@@ -1866,65 +2531,6 @@ Sessions: ${result.sessions.length}
     write(session, renderSessionDescription(session));
     return;
   }
-  if (first === "start-agent") {
-    const projectRef = requireValue(args[1], "Missing project reference");
-    const sourceBranch = requireValue(args[2], "Missing source branch");
-    const agentType = requireValue(args[3], "Missing agent type");
-    if (!AGENT_TYPES.has(agentType)) {
-      throw new Error("Invalid agent type. Expected one of: research, debug, test");
-    }
-    const prompt = args.slice(4).join(" ").trim();
-    if (!prompt) {
-      throw new Error("Agent prompt is required");
-    }
-    const agent = await client.projects.agents.start(projectRef, {
-      sourceBranch,
-      agentType,
-      prompt
-    });
-    write(agent, renderAgentStart(agent));
-    return;
-  }
-  if (first === "agent-status") {
-    const agent = await client.agents.status(requireValue(args[1], "Missing session id"));
-    write(agent, renderAgentStatus(agent));
-    return;
-  }
-  if (first === "send-prompt") {
-    const sessionId = requireValue(args[1], "Missing session id");
-    const prompt = args.slice(2).join(" ").trim();
-    if (!prompt) {
-      throw new Error("Prompt is required");
-    }
-    const agent = await client.agents.sendPrompt(sessionId, { prompt });
-    write(agent, renderAgentStatus(agent));
-    return;
-  }
-  if (first === "merge-changes") {
-    const result = await client.projects.mergeChanges(requireValue(args[1], "Missing project reference"), {
-      targetBranch: requireValue(args[2], "Missing target branch"),
-      sourceBranch: requireValue(args[3], "Missing source branch")
-    });
-    write(result, renderMergeResult(result));
-    return;
-  }
-  if (first === "continue-merge") {
-    const result = await client.projects.continueMerge(requireValue(args[1], "Missing project reference"), {
-      targetBranch: requireValue(args[2], "Missing target branch")
-    });
-    write(result, `Merge committed: ${result.commitHash}
-${result.message}
-`);
-    return;
-  }
-  if (first === "abort-merge") {
-    const result = await client.projects.abortMerge(requireValue(args[1], "Missing project reference"), {
-      targetBranch: requireValue(args[2], "Missing target branch")
-    });
-    write(result, `${result.message}
-`);
-    return;
-  }
   if (first === "sessions" && second === "describe" || first === "describe" && second === "session") {
     const session = await client.sessions.describe(requireValue(args[2], "Missing session id"));
     write(session, renderSessionDescription(session));
@@ -1953,8 +2559,8 @@ ${result.message}
       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;
   }
@@ -1969,33 +2575,30 @@ ${result.message}
   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: 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: randomUUID()
+    });
+    write(read, renderSessionRunStatus(read));
     return;
   }
   throw new Error(`Unknown command: ${args.join(" ")}`);
@@ -2020,6 +2623,18 @@ function resolveCommandExecution(options, rest) {
       text: K8S_HELP_TEXT
     };
   }
+  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: MERGE_HELP_TEXT
+    };
+  }
   if (trailingHelp) {
     const cliOnlyHelp = findCliOnlyCommandHelp(normalizedRest);
     if (cliOnlyHelp) {
@@ -2379,24 +2994,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) {
@@ -2413,102 +3027,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 === "start-agent") {
-    if (!options.project) {
-      throw new Error("--project/-p is required for `start-agent`");
-    }
-    const sourceBranch = commandArgs[0] ?? options.branch;
-    if (!sourceBranch) {
-      throw new Error("Source branch is required for `start-agent`");
-    }
-    const agentType = requireValue(commandArgs[1], "Agent type is required for `start-agent`");
-    if (!AGENT_TYPES.has(agentType)) {
-      throw new Error("Invalid agent type. Expected one of: research, debug, test");
-    }
-    const prompt = commandArgs.slice(2).join(" ").trim();
-    if (!prompt) {
-      throw new Error("Agent prompt is required");
-    }
-    return {
-      kind: "plugin",
-      pluginArgs: ["start-agent", options.project, sourceBranch, agentType, prompt]
-    };
+  if (command === "session") {
+    return { kind: "session-run", command: parseSessionRunCommand(options, commandArgs) };
   }
-  if (command === "agent-status") {
-    const sessionId = commandArgs[0] ?? options.session;
-    if (!sessionId) {
-      throw new Error("Session id is required for `agent-status`");
-    }
-    return {
-      kind: "plugin",
-      pluginArgs: ["agent-status", sessionId]
-    };
-  }
-  if (command === "send-prompt") {
-    const sessionId = options.session ?? commandArgs[0];
-    if (!sessionId) {
-      throw new Error("Session id is required for `send-prompt`");
-    }
-    const promptArgs = options.session ? commandArgs : commandArgs.slice(1);
-    const prompt = promptArgs.join(" ").trim();
-    if (!prompt) {
-      throw new Error("Prompt is required for `send-prompt`");
-    }
-    return {
-      kind: "plugin",
-      pluginArgs: ["send-prompt", sessionId, prompt]
-    };
-  }
-  if (command === "merge-changes") {
-    if (!options.project) {
-      throw new Error("--project/-p is required for `merge-changes`");
-    }
-    const targetBranch = commandArgs[0] ?? options.branch;
-    if (!targetBranch) {
-      throw new Error("Target branch is required for `merge-changes`");
-    }
-    const sourceBranch = requireValue(commandArgs[1], "Sub-agent branch is required for `merge-changes`");
-    return {
-      kind: "plugin",
-      pluginArgs: ["merge-changes", options.project, targetBranch, sourceBranch]
-    };
-  }
-  if (command === "continue-merge") {
-    if (!options.project) {
-      throw new Error("--project/-p is required for `continue-merge`");
-    }
-    const targetBranch = commandArgs[0] ?? options.branch;
-    if (!targetBranch) {
-      throw new Error("Target branch is required for `continue-merge`");
-    }
-    return {
-      kind: "plugin",
-      pluginArgs: ["continue-merge", options.project, targetBranch]
-    };
-  }
-  if (command === "abort-merge") {
-    if (!options.project) {
-      throw new Error("--project/-p is required for `abort-merge`");
-    }
-    const targetBranch = commandArgs[0] ?? options.branch;
-    if (!targetBranch) {
-      throw new Error("Target branch is required for `abort-merge`");
-    }
-    return {
-      kind: "plugin",
-      pluginArgs: ["abort-merge", options.project, targetBranch]
-    };
+  if (command === "merge") {
+    return { kind: "merge", command: parseMergeCommand(options, commandArgs) };
   }
   if (command === "answer-questions") {
     const sessionId = options.session;
@@ -2517,7 +3040,7 @@ function resolveCommandExecution(options, rest) {
     }
     return {
       kind: "plugin",
-      pluginArgs: ["answer-questions", sessionId, ...parseAnswerFlags(commandArgs)]
+      pluginArgs: ["answer-questions", sessionId, ...commandArgs]
     };
   }
   if (command === "answer-env-request") {
@@ -2532,6 +3055,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) {
@@ -2558,6 +3091,38 @@ async function runCommand(argv) {
     process.stdout.write(execution.text);
     return 0;
   }
+  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 runR5dctlShell({
@@ -2606,6 +3171,9 @@ async function main(argv = process.argv.slice(2)) {
 export {
   advanceTransientDevicePollBackoff,
   collectK8sUsage,
+  dispatchMergeCommand,
+  dispatchSessionRunCommand,
+  followR5dctlSession,
   formatK8sCpu,
   formatK8sMemory,
   formatProcessAge,
@@ -2616,7 +3184,9 @@ export {
   getTransientDevicePollDelay,
   handleAuthLogin,
   main,
+  parseAnswerEnvRequestCommandArgs,
   parseAnswerFlags,
+  parseAnswerQuestionsCommandArgs,
   parseConversationRenderArgs,
   parseConversationWorkDetailArgs,
   parseEnvFlags,
@@ -2624,9 +3194,11 @@ export {
   parseGetEnvsArgs,
   parseGlobalArgs,
   parseK8sUsageArgs,
+  parseMergeCommand,
   parsePromptArgs,
   parsePsHistoryArgs,
   parsePsListArgs,
+  parseSessionRunCommand,
   parseSetEnvArgs,
   parseShellArgs,
   readDotenvFile,
@@ -2640,8 +3212,11 @@ export {
   renderProcessHistory,
   renderProcessInspection,
   renderProcessList,
+  renderSessionRunStart,
+  renderSessionRunStatus,
   renderWorkspaceStatus,
   renderWorkspaceSync,
+  renderWorktreeMerge,
   resolveCommandExecution,
   runR5dctlCli,
   summarizeEnvData,