@dench.com/cli 2.6.0 → 2.7.1

package/chat-spawn.ts

@@ -108,6 +108,17 @@ function buildStreamUrlByThreadId(host: string, threadId: string): string {
   return `${host.replace(/\/+$/, "")}/api/chat/stream?sessionId=${encodeURIComponent(threadId)}`;
 }
 
+const CHAT_STREAM_RECONNECT_DELAY_MS = 100;
+const CHAT_STREAM_MAX_EMPTY_BACKOFF_MS = 2_000;
+
+function emptyActiveStreamBackoffMs(consecutiveEmptyResponses: number): number {
+  const exponent = Math.max(0, Math.min(consecutiveEmptyResponses - 1, 10));
+  return Math.min(
+    CHAT_STREAM_RECONNECT_DELAY_MS * 2 ** exponent,
+    CHAT_STREAM_MAX_EMPTY_BACKOFF_MS,
+  );
+}
+
 /**
  * Subscribe to the durable chat stream and pretty-print useful chunks
  * until the stream closes. Mirrors the chunk types the chat panel
@@ -131,37 +142,25 @@ async function followStream(args: {
   runId?: string;
   threadId?: string;
 }): Promise<void> {
-  const url = args.runId
+  const baseUrl = args.runId
     ? buildStreamUrlByRunId(args.host, args.runId)
     : args.threadId
       ? buildStreamUrlByThreadId(args.host, args.threadId)
       : null;
-  if (!url) {
+  if (!baseUrl) {
     throw new ChatSpawnError(
       "followStream requires either { runId } or { threadId }",
     );
   }
-  const response = await fetch(url, {
-    method: "GET",
-    headers: {
-      accept: "text/event-stream",
-      authorization: `Bearer ${args.bearerToken}`,
-    },
-  });
-  if (!response.ok || !response.body) {
-    throw new ChatSpawnError(
-      `Failed to open stream: ${response.status} ${response.statusText}`,
-    );
-  }
-
-  const reader = response.body.getReader();
-  const decoder = new TextDecoder();
-  let buffer = "";
   // Tool calls in flight, keyed by toolCallId, so we can render
   // a single line per call ("→ tool_name … done") instead of
   // dumping every chunk verbatim.
   const inFlightTools = new Map<string, { toolName: string }>();
   let textBuffer = "";
+  let segmentWorkflowRunId: string | null = null;
+  let segmentOrdinal: number | null = null;
+  let startIndex = 0;
+  let consecutiveEmptyActiveResponses = 0;
 
   const flushText = () => {
     if (textBuffer) {
@@ -170,104 +169,199 @@ async function followStream(args: {
     }
   };
 
-  const handleChunk = (raw: string) => {
-    if (!raw.startsWith("data:")) return;
-    const data = raw.slice("data:".length).trim();
-    if (!data || data === "[DONE]") return;
-    let parsed: unknown;
-    try {
-      parsed = JSON.parse(data);
-    } catch {
-      return;
+  const closeInFlightToolLines = (suffix: string) => {
+    if (inFlightTools.size === 0) return false;
+    process.stdout.write(suffix);
+    inFlightTools.clear();
+    return true;
+  };
+
+  while (true) {
+    const url = new URL(baseUrl);
+    if (startIndex > 0) {
+      url.searchParams.set("startIndex", String(startIndex));
     }
-    if (!parsed || typeof parsed !== "object") return;
-    const c = parsed as {
-      type?: unknown;
-      delta?: unknown;
-      text?: unknown;
-      toolName?: unknown;
-      toolCallId?: unknown;
-      input?: unknown;
-      output?: unknown;
-      errorText?: unknown;
-    };
-    switch (c.type) {
-      case "text-delta":
-      case "reasoning-delta": {
-        if (typeof c.delta === "string") {
-          textBuffer += c.delta;
-        }
-        break;
+    const response: Response = await fetch(url, {
+      method: "GET",
+      headers: {
+        accept: "text/event-stream",
+        authorization: `Bearer ${args.bearerToken}`,
+        ...(segmentWorkflowRunId
+          ? {
+              "x-chat-segment-workflow-run-id": segmentWorkflowRunId,
+            }
+          : {}),
+        ...(segmentOrdinal !== null
+          ? { "x-chat-segment-ordinal": String(segmentOrdinal) }
+          : {}),
+      },
+    });
+    const responseWorkflowRunId: string | null =
+      response.headers.get("x-chat-segment-workflow-run-id") ??
+      response.headers.get("x-workflow-run-id");
+    const rawOrdinal = response.headers.get("x-chat-segment-ordinal");
+    const responseOrdinal =
+      rawOrdinal !== null && Number.isSafeInteger(Number(rawOrdinal))
+        ? Number(rawOrdinal)
+        : null;
+    const segmentChanged =
+      (responseWorkflowRunId !== null &&
+        responseWorkflowRunId !== segmentWorkflowRunId) ||
+      (responseOrdinal !== null && responseOrdinal !== segmentOrdinal);
+    if (segmentChanged) {
+      if (segmentWorkflowRunId !== null || segmentOrdinal !== null) {
+        closeInFlightToolLines(" continued in next segment\n");
       }
-      case "tool-input-start": {
-        flushText();
-        if (
-          typeof c.toolCallId === "string" &&
-          typeof c.toolName === "string"
-        ) {
-          inFlightTools.set(c.toolCallId, { toolName: c.toolName });
-          process.stdout.write(`\n→ ${c.toolName} …`);
-        }
-        break;
+      startIndex = 0;
+      consecutiveEmptyActiveResponses = 0;
+    }
+    segmentWorkflowRunId = responseWorkflowRunId ?? segmentWorkflowRunId;
+    segmentOrdinal = responseOrdinal ?? segmentOrdinal;
+
+    if (response.status === 202) {
+      const retryAfterSeconds = Number(response.headers.get("retry-after"));
+      const retryDelayMs =
+        Number.isFinite(retryAfterSeconds) && retryAfterSeconds > 0
+          ? Math.max(50, retryAfterSeconds * 1_000)
+          : 100;
+      await new Promise((resolve) => setTimeout(resolve, retryDelayMs));
+      continue;
+    }
+    if (!response.ok || !response.body) {
+      throw new ChatSpawnError(
+        `Failed to open stream: ${response.status} ${response.statusText}`,
+      );
+    }
+
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    let responseChunkCount = 0;
+    let gotFinish = false;
+
+    const handleChunk = (raw: string) => {
+      if (!raw.startsWith("data:")) return;
+      const data = raw.slice("data:".length).trim();
+      if (!data || data === "[DONE]") return;
+      let parsed: unknown;
+      try {
+        parsed = JSON.parse(data);
+      } catch {
+        return;
       }
-      case "tool-output-available": {
-        flushText();
-        if (typeof c.toolCallId === "string") {
-          const meta = inFlightTools.get(c.toolCallId);
-          inFlightTools.delete(c.toolCallId);
-          process.stdout.write(` done (${meta?.toolName ?? "tool"})\n`);
+      if (!parsed || typeof parsed !== "object") return;
+      responseChunkCount += 1;
+      const c = parsed as {
+        type?: unknown;
+        delta?: unknown;
+        text?: unknown;
+        toolName?: unknown;
+        toolCallId?: unknown;
+        input?: unknown;
+        output?: unknown;
+        errorText?: unknown;
+      };
+      switch (c.type) {
+        case "text-delta":
+        case "reasoning-delta": {
+          if (typeof c.delta === "string") {
+            textBuffer += c.delta;
+          }
+          break;
         }
-        break;
-      }
-      case "tool-output-error": {
-        flushText();
-        if (typeof c.toolCallId === "string") {
-          const meta = inFlightTools.get(c.toolCallId);
-          inFlightTools.delete(c.toolCallId);
-          process.stdout.write(
-            ` error (${meta?.toolName ?? "tool"}): ${
-              typeof c.errorText === "string" ? c.errorText : "unknown"
-            }\n`,
-          );
+        case "tool-input-start": {
+          flushText();
+          if (
+            typeof c.toolCallId === "string" &&
+            typeof c.toolName === "string"
+          ) {
+            inFlightTools.set(c.toolCallId, { toolName: c.toolName });
+            process.stdout.write(`\n→ ${c.toolName} …`);
+          }
+          break;
         }
-        break;
-      }
-      case "finish": {
-        flushText();
-        process.stdout.write("\n");
-        break;
+        case "tool-output-available": {
+          flushText();
+          if (typeof c.toolCallId === "string") {
+            const meta = inFlightTools.get(c.toolCallId);
+            inFlightTools.delete(c.toolCallId);
+            process.stdout.write(` done (${meta?.toolName ?? "tool"})\n`);
+          }
+          break;
+        }
+        case "tool-output-error": {
+          flushText();
+          if (typeof c.toolCallId === "string") {
+            const meta = inFlightTools.get(c.toolCallId);
+            inFlightTools.delete(c.toolCallId);
+            process.stdout.write(
+              ` error (${meta?.toolName ?? "tool"}): ${
+                typeof c.errorText === "string" ? c.errorText : "unknown"
+              }\n`,
+            );
+          }
+          break;
+        }
+        case "finish": {
+          gotFinish = true;
+          flushText();
+          if (!closeInFlightToolLines(" ended\n")) {
+            process.stdout.write("\n");
+          }
+          break;
+        }
+        case "error": {
+          flushText();
+          const msg =
+            typeof c.errorText === "string" ? c.errorText : "stream error";
+          process.stderr.write(`\n[error] ${msg}\n`);
+          break;
+        }
+        default:
+          break;
       }
-      case "error": {
-        flushText();
-        const msg =
-          typeof c.errorText === "string" ? c.errorText : "stream error";
-        process.stderr.write(`\n[error] ${msg}\n`);
-        break;
+    };
+
+    // Read SSE-style chunks. The route uses Vercel AI SDK's
+    // `createUIMessageStreamResponse` which emits `data: {…}\n\n`
+    // lines, so we split on double newlines.
+    while (true) {
+      const { value, done } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+      let nextBreak = buffer.indexOf("\n\n");
+      while (nextBreak !== -1) {
+        const event = buffer.slice(0, nextBreak);
+        buffer = buffer.slice(nextBreak + 2);
+        // Each event may contain multiple `data:` lines.
+        for (const line of event.split("\n")) {
+          if (line.trim().length > 0) handleChunk(line);
+        }
+        nextBreak = buffer.indexOf("\n\n");
       }
-      default:
-        break;
     }
-  };
+    flushText();
+    startIndex += responseChunkCount;
 
-  // Read SSE-style chunks. The route uses Vercel AI SDK's
-  // `createUIMessageStreamResponse` which emits `data: {…}\n\n`
-  // lines, so we split on double newlines.
-  while (true) {
-    const { value, done } = await reader.read();
-    if (done) break;
-    buffer += decoder.decode(value, { stream: true });
-    let nextBreak = buffer.indexOf("\n\n");
-    while (nextBreak !== -1) {
-      const event = buffer.slice(0, nextBreak);
-      buffer = buffer.slice(nextBreak + 2);
-      // Each event may contain multiple `data:` lines.
-      for (const line of event.split("\n")) {
-        if (line.trim().length > 0) handleChunk(line);
-      }
-      nextBreak = buffer.indexOf("\n\n");
+    const streamStatus = response.headers.get("x-workflow-stream-status");
+    const runActive = response.headers.get("X-Run-Active") !== "false";
+    if (gotFinish || !runActive || streamStatus === "terminal") {
+      closeInFlightToolLines(" ended\n");
+      return;
     }
+    // Segment rollover intentionally closes without `finish`; reconnect to
+    // the thread/run route, which resolves the new segment and resets the
+    // durable stream index when the segment identity changes. Empty active
+    // responses can occur during that handoff; back them off so a delayed
+    // rollover cannot turn into a tight polling loop.
+    consecutiveEmptyActiveResponses =
+      responseChunkCount === 0 ? consecutiveEmptyActiveResponses + 1 : 0;
+    const reconnectDelayMs =
+      responseChunkCount === 0
+        ? emptyActiveStreamBackoffMs(consecutiveEmptyActiveResponses)
+        : CHAT_STREAM_RECONNECT_DELAY_MS;
+    await new Promise((resolve) => setTimeout(resolve, reconnectDelayMs));
   }
-  flushText();
 }
 
 function joinPositionalsExceptFlags(args: string[]): string {
@@ -315,17 +409,20 @@ async function runChatNew(ctx: ChatSpawnContext): Promise<void> {
   const payload = result.payload as {
     threadId?: string;
     runId?: string;
+    workflowRunId?: string;
     threadUrl?: string;
     streamUrl?: string;
   } | null;
   out(ctx, payload);
 
-  if (follow && payload?.runId) {
+  if (follow && (payload?.threadId || payload?.workflowRunId)) {
     if (!ctx.jsonOutput) console.error("\n--- following stream ---");
     await followStream({
       host: ctx.runtime.host,
       bearerToken: ctx.runtime.bearerToken,
-      runId: payload.runId,
+      ...(payload.threadId
+        ? { threadId: payload.threadId }
+        : { runId: payload.workflowRunId }),
     });
   }
 }
@@ -371,17 +468,20 @@ async function runChatSend(ctx: ChatSpawnContext): Promise<void> {
   const payload = result.payload as {
     threadId?: string;
     runId?: string;
+    workflowRunId?: string;
     threadUrl?: string;
     streamUrl?: string;
   } | null;
   out(ctx, payload);
 
-  if (follow && payload?.runId) {
+  if (follow && (payload?.threadId || payload?.workflowRunId)) {
     if (!ctx.jsonOutput) console.error("\n--- following stream ---");
     await followStream({
       host: ctx.runtime.host,
       bearerToken: ctx.runtime.bearerToken,
-      runId: payload.runId,
+      ...(payload.threadId
+        ? { threadId: payload.threadId }
+        : { runId: payload.workflowRunId }),
     });
   }
 }
@@ -444,4 +544,4 @@ export async function runChatSpawnCommand(opts: {
   await runChatSend(ctx);
 }
 
-export { ChatSpawnError };
+export { ChatSpawnError, followStream };

package/crm.ts

@@ -3393,11 +3393,14 @@ Workspace members (for user-type fields):
       List \`{ userId, role, name, email }\` for every member of the
       current org. Use the userIds when setting \`Owner\`, \`Assignee\`,
       or any other \`user\`-type field so the UI shows a real linked
-      avatar instead of an unlinked literal-string badge. Check the
+      avatar instead of an unlinked literal-string badge. Pass one id for
+      one assignee or a JSON array for multiple assignees; never drop a
+      co-owner from the source data. Check the
       object's actual field names first (\`crm fields list <object>\`) —
       the \`task\` object uses \`Assignee\`, not \`Owner\`, and some
       workspaces rename \`Name\` to \`Title\`:
         dench crm cells set task <entryId> Assignee '"<userId>"'
+        dench crm cells set task <entryId> Assignee '["<userId1>","<userId2>"]'
         dench crm entries create task --data '{"Name":"X","Assignee":"<userId>"}'
 
 Batch:

package/cron.ts

@@ -18,11 +18,9 @@
  * both formats; we just pass whichever bearer the parent runtime
  * resolved through `sessionToken`.
  *
- * Convex calls go direct via `ConvexHttpClient` (same pattern as
- * `cli/crm.ts`); `run-now` is the one operation that goes through
- * the REST API hop (`POST /api/cron/jobs/<id>/run-now`) because it
- * needs to start a Vercel Workflow which can only be done from a
- * Next.js route.
+ * Convex calls generally go direct via `ConvexHttpClient` (same pattern as
+ * `cli/crm.ts`). Run-now and delete go through REST: run-now starts a Vercel
+ * Workflow, while delete coordinates upstream app-event cleanup.
  *
  * Subcommands:
  *   list                                 List all cron jobs in the org.
@@ -166,6 +164,28 @@ async function getJson(
   return json;
 }
 
+async function deleteJson(
+  url: string,
+  headers: Record<string, string>,
+): Promise<unknown> {
+  const response = await fetch(url, { method: "DELETE", headers });
+  const text = await response.text();
+  let json: unknown;
+  try {
+    json = text ? JSON.parse(text) : null;
+  } catch {
+    json = { raw: text };
+  }
+  if (!response.ok) {
+    const detail =
+      json && typeof json === "object" && "error" in json
+        ? String((json as Record<string, unknown>).error)
+        : JSON.stringify(json);
+    throw new CronCliError(`${url} failed (${response.status}): ${detail}`);
+  }
+  return json;
+}
+
 async function callQuery(
   ctx: CronCliContext,
   fn: Parameters<ConvexHttpClient["query"]>[0],
@@ -339,9 +359,6 @@ const createCronTriggerRef = makeFunctionReference<"mutation">(
 const updateCronTriggerRef = makeFunctionReference<"mutation">(
   "functions/triggers:updateCronTrigger",
 );
-const deleteCronTriggerRef = makeFunctionReference<"mutation">(
-  "functions/triggers:deleteCronTrigger",
-);
 const setCronEnabledRef = makeFunctionReference<"mutation">(
   "functions/triggers:setCronEnabled",
 );
@@ -709,7 +726,10 @@ async function runUpdate(ctx: CronCliContext): Promise<void> {
 
 async function runDelete(ctx: CronCliContext): Promise<void> {
   const jobId = shift(ctx.args, "job id");
-  const result = await callMutation(ctx, deleteCronTriggerRef, { jobId });
+  const result = await deleteJson(
+    `${getApiBase()}/api/cron/jobs/${encodeURIComponent(jobId)}`,
+    apiKeyHeaders(ctx.sessionToken ?? ""),
+  );
   out(ctx, result);
 }
 

package/dench.ts

@@ -10,7 +10,7 @@ import {
   writeFile,
 } from "node:fs/promises";
 import { homedir, hostname, userInfo } from "node:os";
-import { basename, join, relative, resolve } from "node:path";
+import { basename, dirname, join, relative, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { ConvexHttpClient } from "convex/browser";
 import { makeFunctionReference } from "convex/server";
@@ -579,6 +579,7 @@ returns ENOSYS on the FUSE-backed volume mount):
   dench files ls <path> [--json]
   dench files mv <src> <dst> [--json]
   dench files rm <path> [--recursive] [--json]
+  dench files download <path> [<local-dest>] [--url] [--json]
 
 Persist scratch -> workspace (cp from /tmp into /workspace + Convex sync):
   dench stage <local-path> [<workspace-dest>] [--clean] [--json]
@@ -3412,19 +3413,151 @@ async function runFilesRm() {
   });
 }
 
+async function writeLocalFileBytes(localPath: string, bytes: Uint8Array) {
+  const parent = dirname(localPath);
+  if (parent && parent !== ".") {
+    await mkdir(parent, { recursive: true });
+  }
+  await writeFile(localPath, bytes);
+}
+
+async function runFilesDownload() {
+  const runtime = await getRuntime();
+  const apiKey = await requireFilesApiKey(runtime, "dench files download");
+  const targetRaw = positional(2);
+  if (!targetRaw) {
+    throw new CliError(
+      "Usage: dench files download <path> [<local-dest>] [--url]",
+      { code: "files_download_usage" },
+    );
+  }
+  const target = normalizeFilesPath(targetRaw);
+  const jsonOut = hasFlag("--json");
+
+  if (hasFlag("--url")) {
+    const url = (await runtime.client.action(
+      api.functions.files.getFileSignedDownloadUrl,
+      { path: target, apiKey } as never,
+    )) as string | null;
+    if (!url) {
+      throw new CliError(`No downloadable bytes for ${target}`, {
+        code: "files_download_url_not_found",
+        nextActions: [
+          "Directories have no signed URL; run `dench files download <dir>` without --url to fetch the tree.",
+          "Run `dench files ls` on the parent directory to confirm the path.",
+        ],
+      });
+    }
+    if (jsonOut) {
+      print({ ok: true, path: target, url, note: "Signed URL expires." });
+    } else {
+      process.stdout.write(`${url}\n`);
+    }
+    return;
+  }
+
+  const self =
+    target === "/"
+      ? null
+      : (await listConvexTreeAt(runtime, apiKey, parentOfPath(target))).find(
+          (row) => row.path === target,
+        );
+  const isDir = target === "/" || self?.isDir === true;
+
+  if (!isDir) {
+    const bytes = await downloadConvexFileBytes(runtime, apiKey, target);
+    if (!bytes) {
+      throw new CliError(`Not found in Convex: ${target}`, {
+        code: "files_download_not_found",
+        nextActions: [
+          "Run `dench files ls` on the parent directory to confirm.",
+          "If the file only exists on the sandbox FS, run `dench fs sync --initial` first.",
+        ],
+      });
+    }
+    let dest = resolve(positional(3) ?? basename(target));
+    const destStat = await stat(dest).catch(() => null);
+    if (destStat?.isDirectory()) {
+      dest = join(dest, basename(target));
+    }
+    await writeLocalFileBytes(dest, bytes);
+    if (jsonOut) {
+      print({ ok: true, path: target, dest, bytes: bytes.byteLength });
+    } else {
+      process.stdout.write(
+        `dench files download: ${target} -> ${dest} (${bytes.byteLength}B)\n`,
+      );
+    }
+    return;
+  }
+
+  // Directory: recreate the tree locally under <local-dest> (defaults to
+  // the directory's basename in the cwd).
+  const destRoot = resolve(
+    positional(3) ?? (target === "/" ? "workspace" : basename(target)),
+  );
+  const rows = await listConvexTreeRecursive(runtime, apiKey, target);
+  const prefixLength = target === "/" ? 1 : target.length + 1;
+  let downloaded = 0;
+  let bytesTotal = 0;
+  const skipped: string[] = [];
+  await mkdir(destRoot, { recursive: true });
+  for (const row of rows) {
+    const rel = row.path.slice(prefixLength);
+    if (!rel) continue;
+    const local = join(destRoot, rel);
+    if (row.isDir) {
+      await mkdir(local, { recursive: true });
+      continue;
+    }
+    const bytes = await downloadConvexFileBytes(runtime, apiKey, row.path);
+    if (!bytes) {
+      skipped.push(row.path);
+      continue;
+    }
+    await writeLocalFileBytes(local, bytes);
+    downloaded += 1;
+    bytesTotal += bytes.byteLength;
+    if (!jsonOut && downloaded % 25 === 0) {
+      process.stdout.write(
+        `dench files download: ${downloaded} files, ${bytesTotal}B…\n`,
+      );
+    }
+  }
+  if (jsonOut) {
+    print({
+      ok: true,
+      path: target,
+      dest: destRoot,
+      files: downloaded,
+      bytes: bytesTotal,
+      skipped,
+    });
+  } else {
+    process.stdout.write(
+      `dench files download: ${downloaded} files (${bytesTotal}B) -> ${destRoot}${
+        skipped.length > 0 ? ` (${skipped.length} skipped)` : ""
+      }\n`,
+    );
+  }
+}
+
 async function runFilesCommand() {
   const sub = positional(1);
   if (!sub || sub === "help" || hasFlag("--help")) {
     process.stdout.write(
       [
-        "dench files <ls|mv|rm> — workspace file ops that update the UI tree",
+        "dench files <ls|mv|rm|download> — workspace file ops that update the UI tree",
         "",
         "  dench files ls [<path>] [--recursive] [--json]",
         "  dench files mv <src> <dst> [--json]",
         "  dench files rm <path> [--recursive] [--json]",
+        "  dench files download <path> [<local-dest>] [--url] [--json]",
         "",
         "Paths are POSIX paths under /workspace; you can pass either form.",
         "These mutate Convex directly (and the daemon syncs to the volume).",
+        "download fetches canonical bytes from Convex (dirs recurse);",
+        "--url prints a short-lived signed URL instead of saving.",
       ].join("\n"),
     );
     return;
@@ -3432,6 +3565,7 @@ async function runFilesCommand() {
   if (sub === "ls") return await runFilesLs();
   if (sub === "mv") return await runFilesMv();
   if (sub === "rm") return await runFilesRm();
+  if (sub === "download") return await runFilesDownload();
   throw new CliError(`Unknown subcommand: dench files ${sub}`, {
     code: "files_unknown_subcommand",
     nextActions: ["Run dench files help for usage."],

package/email.ts

@@ -197,6 +197,8 @@ Usage:
   dench email identity disable --identity <identityId|email|domain> [--json]
   dench email identity restore --identity <identityId|email|domain> [--json]
   dench email identity delete --identity <identityId|email|domain> [--json]
+  dench email identity forward --identity <identityId|email> --to inbox@you.com [--json]   # forward this sender's sequence replies
+  dench email identity forward --identity <identityId|email> --off [--json]                # turn forwarding off
   dench email send --from founder@example.com --to "Ada <ada@x.com>,bob@y.com" --subject "Hi" (--html-file body.html | --text "...") [--cc ...] [--bcc ...] [--from-name "Ada"] [--reply-to support@x.com] [--reply-message-id <messageId|rfc-id>] [--json]
   dench email message status --message <messageId> [--json]
   dench email message list [--limit 25] [--json]
@@ -500,6 +502,7 @@ async function runIdentity(ctx: EmailCliContext) {
                 `${identity.identityId}  ${identity.fromEmail}  type=${identity.type}` +
                 `${identity.domain ? ` domain=${identity.domain}` : ""}` +
                 `  delivery=${identity.deliveryVerificationStatus}  workspace=${identity.denchVerificationStatus}` +
+                `${identity.forwardRepliesTo ? `  forward=${identity.forwardRepliesTo}` : ""}` +
                 `${identity.disabled ? "  DISABLED" : ""}`,
             )
             .join("\n");
@@ -545,6 +548,34 @@ async function runIdentity(ctx: EmailCliContext) {
     out(ctx, payload, text);
     return;
   }
+  if (sub === "forward") {
+    // Configure where a sender's managed sequence replies are forwarded.
+    // `--to <email>` turns it on (composed from the verified sender, Reply-To =
+    // the prospect); `--off` clears it. Replies are always still captured
+    // in-app regardless — forwarding is an extra copy to a chosen inbox.
+    const identity = requiredFlag(ctx.args, "--identity");
+    const off = hasFlag(ctx.args, "--off");
+    const to = off ? "" : (getFlag(ctx.args, "--to")?.trim() ?? "");
+    if (!off && !to) {
+      throw new Error(
+        "Provide --to <email> to forward this sender's replies, or --off to turn forwarding off.",
+      );
+    }
+    const payload = (await callMutation(
+      ctx,
+      "functions/emailCampaigns:setSenderReplyForward",
+      { identity, forwardRepliesTo: to },
+    )) as JsonRecord;
+    const forwardTo =
+      typeof payload.forwardRepliesTo === "string"
+        ? payload.forwardRepliesTo
+        : null;
+    const text = forwardTo
+      ? `Replies to ${identity}'s sequences will be forwarded to ${forwardTo}.`
+      : `Reply forwarding turned off for ${identity}.`;
+    out(ctx, { ok: true, ...payload }, text);
+    return;
+  }
   if (sub === "dns") {
     const identity = requiredFlag(ctx.args, "--identity");
     if (!identity.includes("@") && !identity.includes(".")) {

package/lib/api-schemas.ts

@@ -44,7 +44,7 @@ export const FIELD_TYPES = [
 const fieldType = z
   .enum(FIELD_TYPES)
   .describe(
-    "Field data type. `relation` needs relatedObjectName + relationshipType; `enum` uses enumValues/enumColors; `user` cells store a member userId; long prose belongs in the protected `Notes` richtext field.",
+    "Field data type. `relation` needs relatedObjectName + relationshipType; `enum` uses enumValues/enumColors; `user` cells store one member userId or an array of member userIds; long prose belongs in the protected `Notes` richtext field.",
   );
 
 const viewKind = z
@@ -139,12 +139,14 @@ const scheduleSpec = z
 
 const dataMap = z
   .record(z.string(), z.unknown())
-  .describe("Field-name -> value map. Use member userIds for `user` fields.");
+  .describe(
+    "Field-name -> value map. For `user` fields use one member userId or a userId array; preserve every assignee.",
+  );
 
 const cellValue = z
   .unknown()
   .describe(
-    "Cell value. Enum=option string, tags=string array, user=member userId, relation=related entry id, boolean=true/false.",
+    "Cell value. Enum=option string, tags=string array, user=one member userId or a userId array, relation=related entry id, boolean=true/false.",
   );
 
 const enrichmentConfig = z
@@ -2277,7 +2279,6 @@ export const responseSchemas: Record<string, ZodTypeAny> = {
         _creationTime: z.number(),
         objectId: z.string(),
         data: fieldsMap,
-        searchableText: z.string(),
         sortOrder: z.number(),
         createdAt: z.number(),
         updatedAt: z.number(),
@@ -2796,7 +2797,11 @@ export const requestExamples: Record<string, unknown> = {
   "crm.fields.enum.color": { color: "#22c55e" },
   "crm.fields.enum.add": { value: "Nurturing", color: "#eab308", position: 2 },
   "crm.entries.create": {
-    data: { Name: "Ada Lovelace", Email: "ada@example.com", Status: "New" },
+    data: {
+      Name: "Joint review",
+      Assignee: ["user_kumar", "user_mark"],
+      Status: "New",
+    },
   },
   "crm.entries.createMany": {
     entries: [
@@ -2804,7 +2809,7 @@ export const requestExamples: Record<string, unknown> = {
       { Name: "Bob", Email: "bob@example.com" },
     ],
   },
-  "crm.cells.set": { value: "In progress" },
+  "crm.cells.set": { value: ["user_kumar", "user_mark"] },
   "crm.query": {
     objectName: "lead",
     dslJson:
@@ -3368,7 +3373,6 @@ export const responseExamples: Record<string, unknown> = {
       _creationTime: 1765526400000,
       objectId: "obj_lead01",
       data: { Name: "Acme Corp", Status: "Qualified" },
-      searchableText: "Acme Corp Qualified",
       sortOrder: 0,
       createdAt: 1765526400000,
       updatedAt: 1765612800000,

package/lib/command-registry.ts

@@ -29,6 +29,7 @@ export type CustomOperation = {
     | "commandsList"
     | "chatSpawn"
     | "chatFollow"
+    | "cronDelete"
     | "cronRunNow"
     | "billingTopup"
     | "upgrade"
@@ -1895,7 +1896,7 @@ const rawApiOperations = [
     path: "/routines/{jobId}",
     requestSchema: anyObject,
     responseSchema: anyResponse,
-    backend: convex("mutation", "functions/triggers:deleteCronTrigger"),
+    backend: custom("cronDelete", "bearer"),
   }),
   op({
     id: "cron.enable",
@@ -1960,7 +1961,7 @@ const rawApiOperations = [
     id: "files.downloadUrl",
     group: "files",
     summary: "Get a signed file download URL.",
-    cli: "dench files ls",
+    cli: "dench files download",
     method: "GET",
     path: "/files/download-url",
     requestSchema: noBody,

package/members.ts

@@ -168,7 +168,9 @@ function membersHelp(): void {
 
 Workspace members for the active organization. Use these userIds when
 assigning CRM \`user\`-type cells (e.g. \`Owner\`, \`Assignee\`) so the
-UI shows a real linked avatar instead of an unlinked literal string.
+UI shows real linked avatars instead of unlinked literal strings. Use one id
+for one assignee or a JSON id array for multiple assignees; preserve every
+owner from the source data.
 
 Subcommands:
   dench members list [--json]
@@ -185,6 +187,7 @@ After picking a userId (confirm field names with
 \`dench crm fields list <object>\` — the default \`task\` uses
 \`Assignee\`, not \`Owner\`, and some workspaces rename \`Name\` to \`Title\`):
   dench crm cells set task <entryId> Assignee '"<userId>"'
+  dench crm cells set task <entryId> Assignee '["<userId1>","<userId2>"]'
   dench crm entries create task --data '{"Name":"Ship CRM","Assignee":"<userId>"}'
 
 The server best-effort-resolves a name / email passed to a \`user\`

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@dench.com/cli",
-  "version": "2.6.0",
-  "description": "Dench agent workspace CLI. v2 unifies auth behind `dench signin`; the legacy `dench login` / `dench onboard` / `dench setup` / `dench what-can-i-do` / `dench register` commands now error with a redirect.",
+  "version": "2.7.1",
+  "description": "Dench agent workspace CLI.",
   "type": "module",
   "bin": {
     "dench": "dench",