@ricsam/r5dctl 0.0.71 → 0.0.73

package/README.md

@@ -71,10 +71,12 @@ r5dctl -s <session-id> conversation --system           # include system prompt m
 r5dctl -s <session-id> conversation --raw --tools --system  # exact raw agent request transcript
 r5dctl -s <session-id> conversation -f                  # print current transcript, then follow new output (--watch also works)
 r5dctl conversation overview <session-id>               # dialogue/thinking with tool work omitted
+r5dctl conversation overview <session-id> --skeleton     # user messages, decisions, and per-turn work markers only
 r5dctl conversation inspect-node <session-id> <node-id>  # raw persisted node plus traversal metadata
 r5dctl conversation inspect-work <session-id> <work-id> # compact call list for one omitted turn
 r5dctl conversation inspect-work <session-id> <work-id> --summary
-r5dctl conversation inspect-work <session-id> <work-id> --full
+r5dctl conversation inspect-work <session-id> <work-id> --full --calls 12-20
+r5dctl conversation inspect-work <session-id> <work-id> --include-polls
 r5dctl conversation move-head <session-id> <node-id>     # rewind or replay the transcript; files stay put
 r5dctl conversation fork <session-id> <node-id>          # copy the branch up to a node into a new session
 r5dctl conversation fork <session-id> <node-id> --name "Retry with tests"
@@ -91,6 +93,8 @@ r5dctl session stop <session-id>
 r5dctl -p <project> merge fix/tests
 r5dctl -p <project> merge --worker <label> --create-conflict-worktree fix/tests
 r5dctl -p <project> merge --worker <label> --launch-conflict-resolution-agent fix/tests
+r5dctl -p <project> merge --worker <label> --launch-conflict-resolution-agent --no-wait fix/tests
+r5dctl -p <project> merge status <attempt-id>
 r5dctl -p <project> merge finish --worker <label> conflicts/fix-tests --summary "Resolved the conflicts"
 
 r5dctl -p <project> -b <branch> shell
@@ -107,12 +111,16 @@ r5dctl k8s usage --window 7d
 r5dctl k8s usage --workload default/api --window 7d --json
 ```
 
-`session start` creates an ordinary agent-mode chat on an explicitly selected existing worktree, or creates a named worktree from an explicit `worktree:<branch>` source. It requires project, worker, model, and prompt and never infers them from the current shell. Starts and prompts return after durable enqueue while execution continues asynchronously. Task specialization belongs in the prompt; there are no predefined debug, explore, research, or test agents.
+`session start` creates an ordinary agent-mode chat on an explicitly selected existing worktree, or creates a named worktree from an explicit `worktree:<branch>` source. It requires project, worker, model, and prompt and never infers them from the current shell. Starts and prompts return after durable enqueue while execution continues asynchronously. Task specialization belongs in the prompt; there are no predefined debug, explore, research, or test agents. `session stop` returns as soon as the agent run is stopped; the stopped worktree's workspace publication finishes asynchronously behind the response, and `merge` republishes at its own boundary before reading the worktree.
 
 Add `-f`/`--follow`/`--watch` to `session start` to attach after enqueue, or to `conversation` to print the current transcript and follow new output. Assistant text is written to stdout and lifecycle/tool progress to stderr; `--tools` includes tool calls and results. With global `--json`, follow mode emits one JSON event per line. Ctrl-C only detaches and never stops the session. The CLI reconnects transiently interrupted event streams and resynchronizes committed conversation revisions without repeating assistant text.
 
 `merge` merges a managed source worktree into its recorded parent. By default conflicts are reported without creating more work. `--create-conflict-worktree` prepares a manual conflict worktree, while `--launch-conflict-resolution-agent` starts the dedicated merge-conflict resolver; those strategies are mutually exclusive. A worker-bound shell credential supplies its own worker automatically; otherwise pass `--worker`. Finish a reviewed manual resolution with `merge finish`.
 
+Merging is lockless and optimistic: nothing blocks agents from continuing to work on the involved branches. Every merge pins the branch tips it previewed and publishes through an atomic compare-and-swap, and a concurrent publication simply retries. When a resolver agent finishes after the target advanced, the platform automatically continues the merge — publishing directly if the refreshed merge is conflict-free, or launching a fresh resolver attempt (whose prompt references the superseded session's resolution) — repeating until one resolution publishes. Superseded attempts surface the follow-up attempt id in `merge status`. Only manual conflict worktrees stop at `stale`: re-run `merge` to start a fresh resolution.
+
+The server answers merge requests as soon as the result is durably recorded; the slow per-member workspace propagation always completes asynchronously behind the response. For a clean merge that means the merged commit is already published when the command returns. For a conflict strategy the server responds with the merge attempt in a `provisioning` state and prepares the conflict worktree (and starts the resolver agent) in the background; the CLI polls the attempt until the worktree is ready — and, for the agent strategy, until the resolver agent is running — before printing the final result. Pass `--no-wait` to skip the wait and get the attempt id immediately, and use `merge status <attempt-id>` at any time to re-check a provisioning, failed, or completed attempt (a provisioning failure surfaces there as a `failed` attempt with its reason). Ctrl-C during the wait only detaches the CLI; provisioning continues server-side.
+
 `shell` connects to the same live worker PTY as the web Shell tab. Without `-c` it attaches the local terminal interactively. With `-c`/`--command`, it runs the supplied shell expression, streams combined PTY output, and exits with the remote command's status. Because command output uses a PTY, stdout and stderr are combined and programs may emit colors or other terminal control sequences.
 
 `ps list` shows active long-running commands managed by r5d. It does not expose the worker host's general OS process table or interactive PTYs. Global project, branch, and session options filter the list, while `--worker` selects a worker label. `ps stop` sends `SIGTERM` to the selected run. Inside an r5d-provided worker shell, the temporary credential can only list and stop runs on that shell's worker.
@@ -132,7 +140,11 @@ Conversation output is human-readable by default and excludes both the system pr
 
 When available, conversation rendering uses the newest complete persisted model-request snapshot on the active conversation branch, so its mode, tier, model, thinking mode, tools, and messages reflect the request that actually ran. Legacy or empty sessions without snapshots fall back to reconstruction from the latest conversation context.
 
-`conversation overview` is a deterministic active-branch projection for recovering earlier work after a fresh-context boundary. It keeps user messages, injected context, assistant thinking/commentary/final responses, and user decisions, while replacing each turn's tool batches with a stable work ID and numbered call ranges. Adjacent tool batches with no visible content between them are coalesced into one range. Use `conversation inspect-work` with that session and work ID to inspect the omitted calls. Inspection is compact by default; `--summary` adds bounded targets/outcomes and `--full` renders persisted inputs and results with the normal tool renderers. The explicit `--compact`, `--summary`, and `--full` flags are mutually exclusive. Compact and summary output are designed to be narrowed with `grep`, `head`, `tail`, `sed`, or `cat -n`.
+`conversation overview` is a deterministic active-branch projection for recovering earlier work after a fresh-context boundary. It keeps user messages, injected context, assistant thinking/commentary/final responses, and user decisions, while replacing each turn's tool batches with a stable work ID and numbered call ranges. Adjacent tool batches with no visible content between them are coalesced into one range. `--skeleton` drops thinking and commentary too, keeping only dialogue, questions/answers, terminal responses, and one work marker per turn — the fastest first read of a long session. When the last turn is unfinished, both views end with a `[Turn in progress: ...]` footer naming the pending state and last node, so "still running" is distinguishable from "ended without a response".
+
+Use `conversation inspect-work` with that session and work ID to inspect the omitted calls. Inspection is compact by default; `--summary` adds bounded targets/outcomes and `--full` renders persisted inputs and results with the normal tool renderers. The explicit `--compact`, `--summary`, and `--full` flags are mutually exclusive. `--calls <n[-m]>` selects a server-side call range while keeping the original call numbers, so a `calls 83–90 omitted` marker in the overview can be inspected directly. Compact and summary output are designed to be narrowed with `grep`, `head`, `tail`, `sed`, or `cat -n`.
+
+Persisted shell results are dispatch-time snapshots, so a long-running command's stored status can go stale. Rendering joins each unresolved run against the durable process-run store: summary rows gain `final_status=`/`final_exitCode=` next to the stale snapshot fields, `--full` appends a `## Final process outcomes` section with byte counts and output tails, and `shell_poll` calls whose run already finished are folded into one `[calls N–M folded: ...]` annotation carrying the final status. `--include-polls` restores the raw poll rows; call numbering never changes either way.
 
 `conversation inspect-node` reads one exact persisted conversation node as formatted JSON. Its header includes the previous node, every direct next node, the next node on the active branch, whether the selected node is active, and the containing `work_...` ID when one is available. This allows callers that start with only a copied chat node ID to traverse nearby nodes or zoom out with `conversation inspect-work`.
 

package/dist/cjs/cli.cjs

@@ -42,13 +42,15 @@ __export(cli_exports, {
   getR5dctlVersion: () => getR5dctlVersion,
   getTransientDevicePollDelay: () => getTransientDevicePollDelay,
   handleAuthLogin: () => handleAuthLogin,
+  isMergeAttemptSettled: () => isMergeAttemptSettled,
   main: () => main,
   parseAnswerEnvRequestCommandArgs: () => parseAnswerEnvRequestCommandArgs,
   parseAnswerFlags: () => parseAnswerFlags,
   parseAnswerQuestionsCommandArgs: () => parseAnswerQuestionsCommandArgs,
   parseConversationForkArgs: () => parseConversationForkArgs,
+  parseConversationInspectWorkArgs: () => parseConversationInspectWorkArgs,
+  parseConversationOverviewArgs: () => parseConversationOverviewArgs,
   parseConversationRenderArgs: () => parseConversationRenderArgs,
-  parseConversationWorkDetailArgs: () => parseConversationWorkDetailArgs,
   parseEnvFlags: () => parseEnvFlags,
   parseEnvRequestResponseArgs: () => parseEnvRequestResponseArgs,
   parseGetEnvsArgs: () => parseGetEnvsArgs,
@@ -95,16 +97,8 @@ var import_promises = require("node:timers/promises");
 var import_dotenv = require("dotenv");
 var import_r5d_api = require("@ricsam/r5d-api");
 var import_shell = require("./shell.cjs");
-const CHAT_MODES = /* @__PURE__ */ new Set([
-  "ask",
-  "plan",
-  "build",
-  "agent",
-  "security_review",
-  "large_diff_remediation",
-  "merge_conflict_resolution"
-]);
-const R5DCTL_SESSION_MODES = /* @__PURE__ */ new Set(["ask", "plan", "build", "agent"]);
+const CHAT_MODES = /* @__PURE__ */ new Set(["ask", "plan", "agent", "large_diff_remediation", "merge_conflict_resolution"]);
+const R5DCTL_SESSION_MODES = /* @__PURE__ */ new Set(["ask", "plan", "agent"]);
 const MODEL_TIERS = /* @__PURE__ */ new Set(["low", "medium", "high", "max"]);
 const R5DCTL_PACKAGE_NAME = "@ricsam/r5dctl";
 const CLI_GLOBAL_OPTION_HELP = [
@@ -173,10 +167,12 @@ const SESSION_RUN_HELP_TEXT = [
 ].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 [--worker <label>] [--create-conflict-worktree|--launch-conflict-resolution-agent] [--no-wait] <source-worktree>",
+  "  r5dctl -p <project> merge status <attempt-id>",
   '  r5dctl -p <project> merge finish --worker <label> [--summary "<summary>"] <conflict-worktree>',
   "",
   "Merge a managed worktree into its recorded parent worktree.",
+  "Conflict worktrees provision in the background; merge waits by default and --no-wait returns the attempt immediately.",
   ""
 ].join("\n");
 const SHARED_HELP_ENTRIES = [
@@ -251,8 +247,8 @@ const SHARED_HELP_ENTRIES = [
   },
   {
     section: "sessions",
-    usage: "conversation overview <session-id>",
-    description: "Read dialogue and thinking while replacing tool work with inspectable ranges."
+    usage: "conversation overview <session-id> [--skeleton]",
+    description: "Read dialogue and thinking while replacing tool work with inspectable ranges; --skeleton keeps only dialogue, decisions, and per-turn work markers."
   },
   {
     section: "sessions",
@@ -261,8 +257,8 @@ const SHARED_HELP_ENTRIES = [
   },
   {
     section: "sessions",
-    usage: "conversation inspect-work <session-id> <work-id> [--compact|--summary|--full]",
-    description: "Inspect one turn's omitted tool work at the selected detail."
+    usage: "conversation inspect-work <session-id> <work-id> [--compact|--summary|--full] [--calls <n[-m]>] [--include-polls]",
+    description: "Inspect one turn's omitted tool work at the selected detail; finished shell polls are folded unless --include-polls."
   },
   {
     section: "sessions",
@@ -327,9 +323,14 @@ const SHARED_HELP_ENTRIES = [
   { section: "processes", usage: "ps stop <run-id>", description: "Gracefully stop an active process with SIGTERM." },
   {
     section: "merge",
-    usage: "-p <project> merge [--worker <label>] [--create-conflict-worktree|--launch-conflict-resolution-agent] <source-worktree>",
+    usage: "-p <project> merge [--worker <label>] [--create-conflict-worktree|--launch-conflict-resolution-agent] [--no-wait] <source-worktree>",
     description: "Merge a worktree into its recorded parent, with an explicit conflict strategy."
   },
+  {
+    section: "merge",
+    usage: "-p <project> merge status <attempt-id>",
+    description: "Show a merge attempt's provisioning and resolution status."
+  },
   {
     section: "merge",
     usage: '-p <project> merge finish --worker <label> [--summary "<summary>"] <conflict-worktree>',
@@ -566,7 +567,7 @@ function requireModel(value) {
 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");
+    throw new Error("Invalid --mode. Expected one of: ask, plan, agent");
   }
   return mode;
 }
@@ -652,12 +653,19 @@ function parseMergeCommand(options, args) {
       ...parsed2.values.get("--summary")?.trim() ? { summary: parsed2.values.get("--summary").trim() } : {}
     };
   }
+  if (args[0] === "status") {
+    const parsed2 = parseCommandOperands(args.slice(1), /* @__PURE__ */ new Set(), /* @__PURE__ */ new Map(), "merge status");
+    const attemptId = requireValue(parsed2.positionals[0], "Attempt id is required for `merge status`");
+    if (parsed2.positionals.length > 1) throw new Error(`Unexpected merge status argument: ${parsed2.positionals[1]}`);
+    return { kind: "status", project, attemptId };
+  }
   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"]
+      ["--launch-conflict-resolution-agent", "--launch-conflict-resolution-agent"],
+      ["--no-wait", "--no-wait"]
     ]),
     "merge"
   );
@@ -670,7 +678,14 @@ function parseMergeCommand(options, args) {
   }
   const conflictMode = createWorktree ? "worktree" : launchAgent ? "agent" : "none";
   const worker = parsed.values.get("--worker")?.trim();
-  return { kind: "merge", project, sourceWorktree, conflictMode, ...worker ? { worker } : {} };
+  return {
+    kind: "merge",
+    project,
+    sourceWorktree,
+    conflictMode,
+    ...worker ? { worker } : {},
+    ...parsed.booleans.has("--no-wait") ? { noWait: true } : {}
+  };
 }
 function assertAuthLoginArgs(args) {
   const valueFlags = /* @__PURE__ */ new Set(["--device-name", "--worker-label"]);
@@ -1958,17 +1973,22 @@ function renderSessionRunStatus(session) {
 function renderWorktreeMerge(result, input) {
   const lines = [];
   appendMergeDetails(lines, result);
+  const status = responseString(result, "status");
   const conflictWorktree = responseString(result, "conflictWorktree");
   const resolverSessionId = responseString(result, "resolverSessionId");
+  const attemptId = responseString(result, "attemptId");
   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") ?? "")) {
+  if (conflictWorktree && worker && ["conflicts", "conflict_worktree_created", "resolving"].includes(status ?? "")) {
     lines.push(
       "",
       "Finish after resolving and reviewing the conflict worktree:",
       `  r5dctl -p ${input.project} merge finish --worker ${worker} ${conflictWorktree} --summary "<summary>"`
     );
   }
+  if (attemptId && (status === "provisioning" || status === "resolving" && result.resolverAgentRunning === false)) {
+    lines.push("", "Check progress:", `  r5dctl -p ${input.project} merge status ${attemptId}`);
+  }
   return `${lines.join("\n")}
 `;
 }
@@ -2008,13 +2028,64 @@ async function dispatchSessionRunCommand(client, command) {
   const data = await client.sessions.stop(command.sessionId);
   return { data, human: renderSessionRunStatus(data) };
 }
-async function dispatchMergeCommand(client, command) {
+const MERGE_POLL_INTERVAL_MS = 2e3;
+const MERGE_POLL_TIMEOUT_MS = 20 * 6e4;
+const MERGE_POLL_MAX_CONSECUTIVE_FAILURES = 5;
+function isMergeAttemptSettled(response) {
+  const status = responseString(response, "status");
+  if (!status) return true;
+  if (status === "resolving") return response.resolverAgentRunning !== false;
+  return status !== "provisioning";
+}
+async function pollMergeAttemptUntilSettled(client, project, attemptId, initial, options) {
+  const intervalMs = options.pollIntervalMs ?? MERGE_POLL_INTERVAL_MS;
+  const timeoutMs = options.pollTimeoutMs ?? MERGE_POLL_TIMEOUT_MS;
+  const sleep2 = options.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
+  const onProgress = options.onProgress ?? (() => {
+  });
+  let latest = initial;
+  let worktreeReadyReported = latest.worktreeReady === true;
+  let consecutiveFailures = 0;
+  let waitedMs = 0;
+  while (!isMergeAttemptSettled(latest)) {
+    if (waitedMs >= timeoutMs) {
+      onProgress(`Still waiting after ${Math.round(timeoutMs / 6e4)} minutes; check later with: r5dctl -p ${project} merge status ${attemptId}`);
+      return latest;
+    }
+    await sleep2(intervalMs);
+    waitedMs += intervalMs;
+    try {
+      latest = await client.projects.worktrees.mergeAttempt(project, attemptId);
+      consecutiveFailures = 0;
+    } catch (error) {
+      consecutiveFailures += 1;
+      if (consecutiveFailures >= MERGE_POLL_MAX_CONSECUTIVE_FAILURES) throw error;
+      continue;
+    }
+    if (!worktreeReadyReported && latest.worktreeReady === true) {
+      worktreeReadyReported = true;
+      onProgress("Conflict worktree ready.");
+    }
+  }
+  return latest;
+}
+async function dispatchMergeCommand(client, command, pollOptions = {}) {
   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 attemptId = responseString(data2, "attemptId");
+    if (command.noWait || !attemptId || isMergeAttemptSettled(data2)) {
+      return { data: data2, human: renderWorktreeMerge(data2, command) };
+    }
+    pollOptions.onProgress?.(`Provisioning the conflict worktree (attempt ${attemptId})...`);
+    const settled = await pollMergeAttemptUntilSettled(client, command.project, attemptId, data2, pollOptions);
+    return { data: settled, human: renderWorktreeMerge(settled, command) };
+  }
+  if (command.kind === "status") {
+    const data2 = await client.projects.worktrees.mergeAttempt(command.project, command.attemptId);
+    return { data: data2, human: renderWorktreeMerge(data2, { project: command.project }) };
   }
   const data = await client.projects.worktrees.finishMerge(command.project, command.conflictWorktree, {
     worker: command.worker,
@@ -2422,21 +2493,57 @@ async function followR5dctlSession(client, sessionId, options) {
   }
   return 0;
 }
-function parseConversationWorkDetailArgs(args) {
+function parseConversationInspectWorkArgs(args) {
   let detail = "compact";
   let selected = false;
-  for (const arg of args) {
+  let calls;
+  let includePolls = false;
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
     const candidate = arg === "--compact" ? "compact" : arg === "--summary" ? "summary" : arg === "--full" ? "full" : void 0;
-    if (!candidate) {
-      throw new Error(`Unknown inspect-work argument: ${arg}`);
+    if (candidate) {
+      if (selected) {
+        throw new Error("Use only one of --compact, --summary, or --full");
+      }
+      detail = candidate;
+      selected = true;
+      continue;
     }
-    if (selected) {
-      throw new Error("Use only one of --compact, --summary, or --full");
+    if (arg === "--calls") {
+      if (calls !== void 0) {
+        throw new Error("Use --calls only once");
+      }
+      index += 1;
+      const value = requireValue(args[index], "Missing value for --calls");
+      if (!/^[0-9]+(-[0-9]+)?$/.test(value)) {
+        throw new Error(`Invalid --calls range: ${value} (use N or N-M)`);
+      }
+      calls = value;
+      continue;
+    }
+    if (arg === "--include-polls") {
+      if (includePolls) {
+        throw new Error("Use --include-polls only once");
+      }
+      includePolls = true;
+      continue;
+    }
+    throw new Error(`Unknown inspect-work argument: ${arg}`);
+  }
+  return { detail, ...calls !== void 0 ? { calls } : {}, includePolls };
+}
+function parseConversationOverviewArgs(args) {
+  let skeleton = false;
+  for (const arg of args) {
+    if (arg !== "--skeleton") {
+      throw new Error(`Unknown conversation overview argument: ${arg}`);
     }
-    detail = candidate;
-    selected = true;
+    if (skeleton) {
+      throw new Error("Use --skeleton only once");
+    }
+    skeleton = true;
   }
-  return detail;
+  return { skeleton };
 }
 function parseConversationForkArgs(args) {
   let name;
@@ -2665,10 +2772,9 @@ Sessions: ${result.sessions.length}
     return;
   }
   if (first === "conversation" && second === "overview") {
-    if (args.length > 3) {
-      throw new Error(`Unexpected conversation overview argument: ${args[3]}`);
-    }
-    const read = await client.sessions.conversationOverview(requireValue(args[2], "Missing session id"));
+    const sessionId = requireValue(args[2], "Missing session id");
+    const { skeleton } = parseConversationOverviewArgs(args.slice(3));
+    const read = await client.sessions.conversationOverview(sessionId, skeleton ? { view: "skeleton" } : {});
     write(read, renderConversationOverviewResponse(read));
     return;
   }
@@ -2703,8 +2809,12 @@ Sessions: ${result.sessions.length}
   if (first === "conversation" && second === "inspect-work") {
     const sessionId = requireValue(args[2], "Missing session id");
     const workId = requireValue(args[3], "Missing work id");
-    const detail = parseConversationWorkDetailArgs(args.slice(4));
-    const read = await client.sessions.inspectConversationWork(sessionId, workId, { detail });
+    const options = parseConversationInspectWorkArgs(args.slice(4));
+    const read = await client.sessions.inspectConversationWork(sessionId, workId, {
+      detail: options.detail,
+      ...options.calls !== void 0 ? { calls: options.calls } : {},
+      ...options.includePolls ? { polls: "include" } : {}
+    });
     write(read, renderConversationWorkResponse(read));
     return;
   }
@@ -3220,6 +3330,14 @@ async function runCommand(argv) {
     return 0;
   }
   if (execution.kind === "session-run") {
+    if (!options.json) {
+      if (execution.command.kind === "start") {
+        process.stderr.write("Starting session (publishing the workspace and provisioning the worktree)...\n");
+      } else if (execution.command.kind === "stop") {
+        process.stderr.write(`Stopping session ${execution.command.sessionId}...
+`);
+      }
+    }
     const result = await dispatchSessionRunCommand(client, execution.command);
     if (execution.command.kind !== "start" || !execution.command.follow) {
       writeDataOutput(options.json, result.data, result.human);
@@ -3236,7 +3354,18 @@ async function runCommand(argv) {
     });
   }
   if (execution.kind === "merge") {
-    const result = await dispatchMergeCommand(client, execution.command);
+    if (!options.json) {
+      if (execution.command.kind === "merge") {
+        process.stderr.write("Merging (publishing the workspace and computing the merge)...\n");
+      } else if (execution.command.kind === "finish") {
+        process.stderr.write(`Finalizing ${execution.command.conflictWorktree} (publishing the resolver workspace)...
+`);
+      }
+    }
+    const result = await dispatchMergeCommand(client, execution.command, {
+      ...options.json ? {} : { onProgress: (line) => process.stderr.write(`${line}
+`) }
+    });
     writeDataOutput(options.json, result.data, result.human);
     return 0;
   }
@@ -3312,13 +3441,15 @@ async function main(argv = process.argv.slice(2)) {
   getR5dctlVersion,
   getTransientDevicePollDelay,
   handleAuthLogin,
+  isMergeAttemptSettled,
   main,
   parseAnswerEnvRequestCommandArgs,
   parseAnswerFlags,
   parseAnswerQuestionsCommandArgs,
   parseConversationForkArgs,
+  parseConversationInspectWorkArgs,
+  parseConversationOverviewArgs,
   parseConversationRenderArgs,
-  parseConversationWorkDetailArgs,
   parseEnvFlags,
   parseEnvRequestResponseArgs,
   parseGetEnvsArgs,

package/dist/cjs/package.json

@@ -1,5 +1,5 @@
 {
   "name": "@ricsam/r5dctl",
-  "version": "0.0.71",
+  "version": "0.0.73",
   "type": "commonjs"
 }

package/dist/mjs/cli.mjs

@@ -11,16 +11,8 @@ import {
   R5dctlClient
 } from "@ricsam/r5d-api";
 import { runR5dctlShell } from "./shell.mjs";
-const CHAT_MODES = /* @__PURE__ */ new Set([
-  "ask",
-  "plan",
-  "build",
-  "agent",
-  "security_review",
-  "large_diff_remediation",
-  "merge_conflict_resolution"
-]);
-const R5DCTL_SESSION_MODES = /* @__PURE__ */ new Set(["ask", "plan", "build", "agent"]);
+const CHAT_MODES = /* @__PURE__ */ new Set(["ask", "plan", "agent", "large_diff_remediation", "merge_conflict_resolution"]);
+const R5DCTL_SESSION_MODES = /* @__PURE__ */ new Set(["ask", "plan", "agent"]);
 const MODEL_TIERS = /* @__PURE__ */ new Set(["low", "medium", "high", "max"]);
 const R5DCTL_PACKAGE_NAME = "@ricsam/r5dctl";
 const CLI_GLOBAL_OPTION_HELP = [
@@ -89,10 +81,12 @@ const SESSION_RUN_HELP_TEXT = [
 ].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 [--worker <label>] [--create-conflict-worktree|--launch-conflict-resolution-agent] [--no-wait] <source-worktree>",
+  "  r5dctl -p <project> merge status <attempt-id>",
   '  r5dctl -p <project> merge finish --worker <label> [--summary "<summary>"] <conflict-worktree>',
   "",
   "Merge a managed worktree into its recorded parent worktree.",
+  "Conflict worktrees provision in the background; merge waits by default and --no-wait returns the attempt immediately.",
   ""
 ].join("\n");
 const SHARED_HELP_ENTRIES = [
@@ -167,8 +161,8 @@ const SHARED_HELP_ENTRIES = [
   },
   {
     section: "sessions",
-    usage: "conversation overview <session-id>",
-    description: "Read dialogue and thinking while replacing tool work with inspectable ranges."
+    usage: "conversation overview <session-id> [--skeleton]",
+    description: "Read dialogue and thinking while replacing tool work with inspectable ranges; --skeleton keeps only dialogue, decisions, and per-turn work markers."
   },
   {
     section: "sessions",
@@ -177,8 +171,8 @@ const SHARED_HELP_ENTRIES = [
   },
   {
     section: "sessions",
-    usage: "conversation inspect-work <session-id> <work-id> [--compact|--summary|--full]",
-    description: "Inspect one turn's omitted tool work at the selected detail."
+    usage: "conversation inspect-work <session-id> <work-id> [--compact|--summary|--full] [--calls <n[-m]>] [--include-polls]",
+    description: "Inspect one turn's omitted tool work at the selected detail; finished shell polls are folded unless --include-polls."
   },
   {
     section: "sessions",
@@ -243,9 +237,14 @@ const SHARED_HELP_ENTRIES = [
   { section: "processes", usage: "ps stop <run-id>", description: "Gracefully stop an active process with SIGTERM." },
   {
     section: "merge",
-    usage: "-p <project> merge [--worker <label>] [--create-conflict-worktree|--launch-conflict-resolution-agent] <source-worktree>",
+    usage: "-p <project> merge [--worker <label>] [--create-conflict-worktree|--launch-conflict-resolution-agent] [--no-wait] <source-worktree>",
     description: "Merge a worktree into its recorded parent, with an explicit conflict strategy."
   },
+  {
+    section: "merge",
+    usage: "-p <project> merge status <attempt-id>",
+    description: "Show a merge attempt's provisioning and resolution status."
+  },
   {
     section: "merge",
     usage: '-p <project> merge finish --worker <label> [--summary "<summary>"] <conflict-worktree>',
@@ -482,7 +481,7 @@ function requireModel(value) {
 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");
+    throw new Error("Invalid --mode. Expected one of: ask, plan, agent");
   }
   return mode;
 }
@@ -568,12 +567,19 @@ function parseMergeCommand(options, args) {
       ...parsed2.values.get("--summary")?.trim() ? { summary: parsed2.values.get("--summary").trim() } : {}
     };
   }
+  if (args[0] === "status") {
+    const parsed2 = parseCommandOperands(args.slice(1), /* @__PURE__ */ new Set(), /* @__PURE__ */ new Map(), "merge status");
+    const attemptId = requireValue(parsed2.positionals[0], "Attempt id is required for `merge status`");
+    if (parsed2.positionals.length > 1) throw new Error(`Unexpected merge status argument: ${parsed2.positionals[1]}`);
+    return { kind: "status", project, attemptId };
+  }
   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"]
+      ["--launch-conflict-resolution-agent", "--launch-conflict-resolution-agent"],
+      ["--no-wait", "--no-wait"]
     ]),
     "merge"
   );
@@ -586,7 +592,14 @@ function parseMergeCommand(options, args) {
   }
   const conflictMode = createWorktree ? "worktree" : launchAgent ? "agent" : "none";
   const worker = parsed.values.get("--worker")?.trim();
-  return { kind: "merge", project, sourceWorktree, conflictMode, ...worker ? { worker } : {} };
+  return {
+    kind: "merge",
+    project,
+    sourceWorktree,
+    conflictMode,
+    ...worker ? { worker } : {},
+    ...parsed.booleans.has("--no-wait") ? { noWait: true } : {}
+  };
 }
 function assertAuthLoginArgs(args) {
   const valueFlags = /* @__PURE__ */ new Set(["--device-name", "--worker-label"]);
@@ -1874,17 +1887,22 @@ function renderSessionRunStatus(session) {
 function renderWorktreeMerge(result, input) {
   const lines = [];
   appendMergeDetails(lines, result);
+  const status = responseString(result, "status");
   const conflictWorktree = responseString(result, "conflictWorktree");
   const resolverSessionId = responseString(result, "resolverSessionId");
+  const attemptId = responseString(result, "attemptId");
   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") ?? "")) {
+  if (conflictWorktree && worker && ["conflicts", "conflict_worktree_created", "resolving"].includes(status ?? "")) {
     lines.push(
       "",
       "Finish after resolving and reviewing the conflict worktree:",
       `  r5dctl -p ${input.project} merge finish --worker ${worker} ${conflictWorktree} --summary "<summary>"`
     );
   }
+  if (attemptId && (status === "provisioning" || status === "resolving" && result.resolverAgentRunning === false)) {
+    lines.push("", "Check progress:", `  r5dctl -p ${input.project} merge status ${attemptId}`);
+  }
   return `${lines.join("\n")}
 `;
 }
@@ -1924,13 +1942,64 @@ async function dispatchSessionRunCommand(client, command) {
   const data = await client.sessions.stop(command.sessionId);
   return { data, human: renderSessionRunStatus(data) };
 }
-async function dispatchMergeCommand(client, command) {
+const MERGE_POLL_INTERVAL_MS = 2e3;
+const MERGE_POLL_TIMEOUT_MS = 20 * 6e4;
+const MERGE_POLL_MAX_CONSECUTIVE_FAILURES = 5;
+function isMergeAttemptSettled(response) {
+  const status = responseString(response, "status");
+  if (!status) return true;
+  if (status === "resolving") return response.resolverAgentRunning !== false;
+  return status !== "provisioning";
+}
+async function pollMergeAttemptUntilSettled(client, project, attemptId, initial, options) {
+  const intervalMs = options.pollIntervalMs ?? MERGE_POLL_INTERVAL_MS;
+  const timeoutMs = options.pollTimeoutMs ?? MERGE_POLL_TIMEOUT_MS;
+  const sleep2 = options.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
+  const onProgress = options.onProgress ?? (() => {
+  });
+  let latest = initial;
+  let worktreeReadyReported = latest.worktreeReady === true;
+  let consecutiveFailures = 0;
+  let waitedMs = 0;
+  while (!isMergeAttemptSettled(latest)) {
+    if (waitedMs >= timeoutMs) {
+      onProgress(`Still waiting after ${Math.round(timeoutMs / 6e4)} minutes; check later with: r5dctl -p ${project} merge status ${attemptId}`);
+      return latest;
+    }
+    await sleep2(intervalMs);
+    waitedMs += intervalMs;
+    try {
+      latest = await client.projects.worktrees.mergeAttempt(project, attemptId);
+      consecutiveFailures = 0;
+    } catch (error) {
+      consecutiveFailures += 1;
+      if (consecutiveFailures >= MERGE_POLL_MAX_CONSECUTIVE_FAILURES) throw error;
+      continue;
+    }
+    if (!worktreeReadyReported && latest.worktreeReady === true) {
+      worktreeReadyReported = true;
+      onProgress("Conflict worktree ready.");
+    }
+  }
+  return latest;
+}
+async function dispatchMergeCommand(client, command, pollOptions = {}) {
   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 attemptId = responseString(data2, "attemptId");
+    if (command.noWait || !attemptId || isMergeAttemptSettled(data2)) {
+      return { data: data2, human: renderWorktreeMerge(data2, command) };
+    }
+    pollOptions.onProgress?.(`Provisioning the conflict worktree (attempt ${attemptId})...`);
+    const settled = await pollMergeAttemptUntilSettled(client, command.project, attemptId, data2, pollOptions);
+    return { data: settled, human: renderWorktreeMerge(settled, command) };
+  }
+  if (command.kind === "status") {
+    const data2 = await client.projects.worktrees.mergeAttempt(command.project, command.attemptId);
+    return { data: data2, human: renderWorktreeMerge(data2, { project: command.project }) };
   }
   const data = await client.projects.worktrees.finishMerge(command.project, command.conflictWorktree, {
     worker: command.worker,
@@ -2338,21 +2407,57 @@ async function followR5dctlSession(client, sessionId, options) {
   }
   return 0;
 }
-function parseConversationWorkDetailArgs(args) {
+function parseConversationInspectWorkArgs(args) {
   let detail = "compact";
   let selected = false;
-  for (const arg of args) {
+  let calls;
+  let includePolls = false;
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
     const candidate = arg === "--compact" ? "compact" : arg === "--summary" ? "summary" : arg === "--full" ? "full" : void 0;
-    if (!candidate) {
-      throw new Error(`Unknown inspect-work argument: ${arg}`);
+    if (candidate) {
+      if (selected) {
+        throw new Error("Use only one of --compact, --summary, or --full");
+      }
+      detail = candidate;
+      selected = true;
+      continue;
     }
-    if (selected) {
-      throw new Error("Use only one of --compact, --summary, or --full");
+    if (arg === "--calls") {
+      if (calls !== void 0) {
+        throw new Error("Use --calls only once");
+      }
+      index += 1;
+      const value = requireValue(args[index], "Missing value for --calls");
+      if (!/^[0-9]+(-[0-9]+)?$/.test(value)) {
+        throw new Error(`Invalid --calls range: ${value} (use N or N-M)`);
+      }
+      calls = value;
+      continue;
+    }
+    if (arg === "--include-polls") {
+      if (includePolls) {
+        throw new Error("Use --include-polls only once");
+      }
+      includePolls = true;
+      continue;
+    }
+    throw new Error(`Unknown inspect-work argument: ${arg}`);
+  }
+  return { detail, ...calls !== void 0 ? { calls } : {}, includePolls };
+}
+function parseConversationOverviewArgs(args) {
+  let skeleton = false;
+  for (const arg of args) {
+    if (arg !== "--skeleton") {
+      throw new Error(`Unknown conversation overview argument: ${arg}`);
     }
-    detail = candidate;
-    selected = true;
+    if (skeleton) {
+      throw new Error("Use --skeleton only once");
+    }
+    skeleton = true;
   }
-  return detail;
+  return { skeleton };
 }
 function parseConversationForkArgs(args) {
   let name;
@@ -2581,10 +2686,9 @@ Sessions: ${result.sessions.length}
     return;
   }
   if (first === "conversation" && second === "overview") {
-    if (args.length > 3) {
-      throw new Error(`Unexpected conversation overview argument: ${args[3]}`);
-    }
-    const read = await client.sessions.conversationOverview(requireValue(args[2], "Missing session id"));
+    const sessionId = requireValue(args[2], "Missing session id");
+    const { skeleton } = parseConversationOverviewArgs(args.slice(3));
+    const read = await client.sessions.conversationOverview(sessionId, skeleton ? { view: "skeleton" } : {});
     write(read, renderConversationOverviewResponse(read));
     return;
   }
@@ -2619,8 +2723,12 @@ Sessions: ${result.sessions.length}
   if (first === "conversation" && second === "inspect-work") {
     const sessionId = requireValue(args[2], "Missing session id");
     const workId = requireValue(args[3], "Missing work id");
-    const detail = parseConversationWorkDetailArgs(args.slice(4));
-    const read = await client.sessions.inspectConversationWork(sessionId, workId, { detail });
+    const options = parseConversationInspectWorkArgs(args.slice(4));
+    const read = await client.sessions.inspectConversationWork(sessionId, workId, {
+      detail: options.detail,
+      ...options.calls !== void 0 ? { calls: options.calls } : {},
+      ...options.includePolls ? { polls: "include" } : {}
+    });
     write(read, renderConversationWorkResponse(read));
     return;
   }
@@ -3136,6 +3244,14 @@ async function runCommand(argv) {
     return 0;
   }
   if (execution.kind === "session-run") {
+    if (!options.json) {
+      if (execution.command.kind === "start") {
+        process.stderr.write("Starting session (publishing the workspace and provisioning the worktree)...\n");
+      } else if (execution.command.kind === "stop") {
+        process.stderr.write(`Stopping session ${execution.command.sessionId}...
+`);
+      }
+    }
     const result = await dispatchSessionRunCommand(client, execution.command);
     if (execution.command.kind !== "start" || !execution.command.follow) {
       writeDataOutput(options.json, result.data, result.human);
@@ -3152,7 +3268,18 @@ async function runCommand(argv) {
     });
   }
   if (execution.kind === "merge") {
-    const result = await dispatchMergeCommand(client, execution.command);
+    if (!options.json) {
+      if (execution.command.kind === "merge") {
+        process.stderr.write("Merging (publishing the workspace and computing the merge)...\n");
+      } else if (execution.command.kind === "finish") {
+        process.stderr.write(`Finalizing ${execution.command.conflictWorktree} (publishing the resolver workspace)...
+`);
+      }
+    }
+    const result = await dispatchMergeCommand(client, execution.command, {
+      ...options.json ? {} : { onProgress: (line) => process.stderr.write(`${line}
+`) }
+    });
     writeDataOutput(options.json, result.data, result.human);
     return 0;
   }
@@ -3227,13 +3354,15 @@ export {
   getR5dctlVersion,
   getTransientDevicePollDelay,
   handleAuthLogin,
+  isMergeAttemptSettled,
   main,
   parseAnswerEnvRequestCommandArgs,
   parseAnswerFlags,
   parseAnswerQuestionsCommandArgs,
   parseConversationForkArgs,
+  parseConversationInspectWorkArgs,
+  parseConversationOverviewArgs,
   parseConversationRenderArgs,
-  parseConversationWorkDetailArgs,
   parseEnvFlags,
   parseEnvRequestResponseArgs,
   parseGetEnvsArgs,

package/dist/mjs/package.json

@@ -1,5 +1,5 @@
 {
   "name": "@ricsam/r5dctl",
-  "version": "0.0.71",
+  "version": "0.0.73",
   "type": "module"
 }

package/dist/types/cli.d.ts

@@ -85,6 +85,11 @@ export type R5dctlMergeCommand = {
     sourceWorktree: string;
     worker?: string;
     conflictMode: R5dctlMergeConflictMode;
+    noWait?: boolean;
+} | {
+    kind: "status";
+    project: string;
+    attemptId: string;
 } | {
     kind: "finish";
     project: string;
@@ -229,6 +234,8 @@ export type R5dctlCommandResponse = {
     conflictedFiles?: string[];
     failureReason?: string;
     message?: string;
+    worktreeReady?: boolean;
+    resolverAgentRunning?: boolean;
 };
 export type R5dctlSessionRunClient = {
     projects: {
@@ -259,6 +266,7 @@ export type R5dctlMergeClient = {
                 worker: string;
                 summary?: string;
             }) => Promise<R5dctlCommandResponse>;
+            mergeAttempt: (projectRef: string, attemptId: string) => Promise<R5dctlCommandResponse>;
         };
     };
 };
@@ -273,7 +281,21 @@ export type R5dctlCommandDispatchResult = {
     human: string;
 };
 export declare function dispatchSessionRunCommand(client: R5dctlSessionRunClient, command: R5dctlSessionRunCommand): Promise<R5dctlCommandDispatchResult>;
-export declare function dispatchMergeCommand(client: R5dctlMergeClient, command: R5dctlMergeCommand): Promise<R5dctlCommandDispatchResult>;
+export type R5dctlMergePollOptions = {
+    onProgress?: (line: string) => void;
+    pollIntervalMs?: number;
+    pollTimeoutMs?: number;
+    sleep?: (ms: number) => Promise<void>;
+};
+/**
+ * Whether a merge attempt response is settled for the CLI: terminal, waiting
+ * on the user (a ready manual conflict worktree), or actively resolving with
+ * its agent running. Anything else is still provisioning or starting. A
+ * "resolving" response without the resolverAgentRunning field comes from a
+ * server that starts the agent in-request, so it counts as settled.
+ */
+export declare function isMergeAttemptSettled(response: R5dctlCommandResponse): boolean;
+export declare function dispatchMergeCommand(client: R5dctlMergeClient, command: R5dctlMergeCommand, pollOptions?: R5dctlMergePollOptions): Promise<R5dctlCommandDispatchResult>;
 export declare function parseConversationRenderArgs(args: string[]): ConversationRenderOptions;
 export declare function renderConversationResponse(read: R5dctlConversationResponse): string;
 type R5dctlFollowClient = {
@@ -298,7 +320,15 @@ export type R5dctlFollowOptions = {
     maxReconnects?: number;
 };
 export declare function followR5dctlSession(client: R5dctlFollowClient, sessionId: string, options: R5dctlFollowOptions): Promise<number>;
-export declare function parseConversationWorkDetailArgs(args: string[]): R5dctlConversationWorkDetail;
+export type ConversationInspectWorkOptions = {
+    detail: R5dctlConversationWorkDetail;
+    calls?: string;
+    includePolls: boolean;
+};
+export declare function parseConversationInspectWorkArgs(args: string[]): ConversationInspectWorkOptions;
+export declare function parseConversationOverviewArgs(args: string[]): {
+    skeleton: boolean;
+};
 export declare function parseConversationForkArgs(args: string[]): string | undefined;
 export declare function renderConversationOverviewResponse(read: R5dctlConversationOverviewResponse): string;
 export declare function renderConversationNodeResponse(read: R5dctlConversationNodeResponse): string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ricsam/r5dctl",
-  "version": "0.0.71",
+  "version": "0.0.73",
   "type": "module",
   "main": "./dist/cjs/cli.cjs",
   "module": "./dist/mjs/cli.mjs",
@@ -26,7 +26,7 @@
     "r5dctl": "dist/cjs/main.cjs"
   },
   "dependencies": {
-    "@ricsam/r5d-api": "^0.0.71",
+    "@ricsam/r5d-api": "^0.0.73",
     "dotenv": "^17",
     "qrcode": "^1.5.4",
     "ws": "^8.18.3"