@love-moon/conductor-cli 0.16.0 → 0.17.1

package/bin/conductor-task.js

@@ -19,11 +19,13 @@
  *   schedule update <id> <schedule-id> [<message>] [--delay|--at|--every ...]
  *   stop <id> | interrupt <id> [--target-reply-to <msg-id>]
  *   restart <id> [--strategy inplace|new_task] [--backend] [--refresh-session]
- *           [--daemon-host <h>] [--first-message <text>]
+ *           [--daemon-host <h>] [--code-host <h>] [--first-message <text> [--new-worktree]]
  *   delete <id> --yes [--permanent] | archive <id> | unarchive <id> [--daemon-host <h>]
  *   rename <id> <title> | pin <id> | unpin <id> | labels <id> [<label-id>...] [--clear]
  *   move <id> [<project>] [--back] | share <id> | unshare <id> | shared <token|link>
+ *   preview <id> <path>
  *   transcribe <audio.wav|mp3> [--language <tag>]
+ *   speak <text> [-o FILE|-]
  *   persistent <id> [--enable|--disable] [--instructions ...] [--summary ...]
  *   round end <id> | round start <id> [<message>] [--backend] [--daemon-host] [--worktree inherit|new|none]
  *   cleanup-worktree <id> | terminal open|close|show <id>
@@ -31,8 +33,7 @@
  *   resume --daemon-host <h> --backend <b> --session <id> [--session-file <p>] [--title] [--prompt]
  *
  *   create also takes: --daemon-host, --agent <name>[:backend] (repeatable; first
- *   is the worker), --global-backend <host>:<backend>, --worktree,
- *   --remote-worktree <host>, --persistent
+ *   is the worker), --global-backend <backend>@<host>, --worktree, --persistent
  *   send also takes: --attach FILE (repeatable)
  *   messages also takes: --follow [--interval <sec>] [--until-idle]
  *   list also takes (without --archived): --all-projects, --project-ids a,b
@@ -351,6 +352,16 @@ async function handleList(argv, deps) {
 }
 
 async function handleCreate(argv, deps) {
+  // Removed flag: an unknown argument only warns, and would start a plain local task.
+  if (argv.remoteWorktree !== undefined) {
+    const err = new Error(
+      "--remote-worktree was removed. Create the task in the project on the daemon that holds the code, "
+        + "with --global-backend <backend>@<ai-host> --worktree: the host now names the daemon that runs the AI, "
+        + "not the one that holds the code.",
+    );
+    err.code = "ARGS";
+    throw err;
+  }
   const apis = await buildApis(deps);
   const project = await resolveProject(apis, {
     env: deps.env,
@@ -774,9 +785,9 @@ export async function main(argvInput = hideBin(process.argv), deps = {}) {
             array: true,
             describe: "Multi-agent group member <name>[:backend]; repeat it. The first is the worker, the rest reviewers",
           })
-          .option("global-backend", { type: "string", describe: "Run the AI on a global backend <host>:<backend> (RFC 0041)" })
+          .option("global-backend", { type: "string", describe: "Run the AI on a global AI backend from settings, as <backend>@<host>" })
           .option("worktree", { type: "boolean", describe: "Run in a new git worktree on the project's daemon" })
-          .option("remote-worktree", { type: "string", describe: "Run in a new git worktree on this remote daemon" })
+          .option("remote-worktree", { type: "string", hidden: true })
           .option("persistent", { type: "boolean", describe: "Create a persistent task (RFC 0039)" }),
         async (argv) => {
           exitCode = await handleCreate(argv, { ...handlerDeps, configFile: argv.configFile });
@@ -862,8 +873,10 @@ export async function main(argvInput = hideBin(process.argv), deps = {}) {
           .option("strategy", { choices: ["inplace", "new_task"], describe: "inplace resumes the session; new_task forks a successor" })
           .option("backend", { type: "string", describe: "Switch to this AI backend" })
           .option("refresh-session", { type: "boolean", default: false, describe: "Start a fresh AI session in place" })
-          .option("daemon-host", { type: "string", describe: "Run the restarted session on this daemon" })
-          .option("first-message", { type: "string", describe: "With --strategy new_task: first message instead of the transcript handoff" }),
+          .option("daemon-host", { type: "string", describe: "Run the restarted AI on this daemon; with --strategy new_task it keeps working on the source task's code remotely when it can (add --code-host <same> to move the work there instead)" })
+          .option("code-host", { type: "string", describe: "With --strategy new_task: daemon holding the code (default: the source task's); another daemon moves the work there and needs --daemon-host set to it" })
+          .option("first-message", { type: "string", describe: "With --strategy new_task: first message instead of the transcript handoff" })
+          .option("new-worktree", { type: "boolean", default: false, describe: "With --strategy new_task and --first-message: run the new task in its own fresh git worktree (a parallel branch) instead of the source task's workspace, without loading the source conversation; the source keeps its place in its agent group" }),
         run(extra.handleRestart),
       )
       .command(
@@ -932,6 +945,14 @@ export async function main(argvInput = hideBin(process.argv), deps = {}) {
         (cmd) => cmd.positional("id", { type: "string", demandOption: true }),
         run(extra.handleShare),
       )
+      .command(
+        "preview <id> <path>",
+        "Open a temporary link to a file on the task's daemon (HTML, Markdown, images…)",
+        (cmd) => cmd
+          .positional("id", { type: "string", demandOption: true })
+          .positional("path", { type: "string", demandOption: true, describe: "Absolute, ~/ or relative to the task's working directory" }),
+        run(extra.handlePreview),
+      )
       .command(
         "unshare <id>",
         "Revoke a task's share link",
@@ -952,6 +973,14 @@ export async function main(argvInput = hideBin(process.argv), deps = {}) {
           .option("language", { type: "string", describe: "Language hint, e.g. zh or en" }),
         run(extra.handleTranscribe),
       )
+      .command(
+        "speak <text>",
+        "Text to speech as .mp3 (the web voice mode's reply voice)",
+        (cmd) => cmd
+          .positional("text", { type: "string", demandOption: true })
+          .option("output", { alias: "o", type: "string", describe: "Output file (default speech.mp3), or - for stdout" }),
+        run(extra.handleSpeak),
+      )
       .command(
         "persistent <id>",
         "Change persistent-task settings (RFC 0039)",

package/bin/conductor-update.js

@@ -17,6 +17,7 @@ import {
   fetchLatestVersion,
   isNewerVersion,
   detectPackageManager,
+  resolveBundledNodeDir,
   resolveGlobalInstallPrefix,
 } from "../src/version-check.js";
 import {
@@ -31,6 +32,7 @@ const PKG_ROOT = path.join(__dirname, "..");
 
 const pkgJson = JSON.parse(fs.readFileSync(path.join(PKG_ROOT, "package.json"), "utf-8"));
 const CURRENT_VERSION = pkgJson.version;
+const INSTALL_TIMEOUT_MS = 15 * 60_000;
 const INSTALL_METHOD = resolveInstallMethod({
   env: process.env,
   packageRoot: PKG_ROOT,
@@ -176,6 +178,11 @@ async function performUpdate() {
     console.log("");
   }
 
+  const nodeDir = resolveBundledNodeDir();
+  if (nodeDir && !process.env.npm_config_nodedir) {
+    process.env.npm_config_nodedir = nodeDir;
+  }
+
   if (packageManager === "pnpm") {
     console.log("   Preparing pnpm native dependency allowlist...");
     await ensurePnpmOnlyBuiltDependencies({
@@ -212,16 +219,26 @@ async function performUpdate() {
       stdio: "inherit",
       shell: true
     });
+    // npm never gives up on a registry connection that stalls mid-handshake.
+    let timedOut = false;
+    const timer = setTimeout(() => {
+      timedOut = true;
+      child.kill("SIGTERM");
+    }, INSTALL_TIMEOUT_MS);
 
     child.on("close", (code) => {
+      clearTimeout(timer);
       if (code === 0) {
         resolve();
+      } else if (timedOut) {
+        reject(new Error(`${cmd} did not finish within ${INSTALL_TIMEOUT_MS / 60_000} minutes`));
       } else {
         reject(new Error(`Exit code ${code}`));
       }
     });
 
     child.on("error", (error) => {
+      clearTimeout(timer);
       reject(error);
     });
   });

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@love-moon/conductor-cli",
-  "version": "0.16.0",
-  "gitCommitId": "77239b9",
+  "version": "0.17.1",
+  "gitCommitId": "e3dbbad",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/lovemoon-ai/conductor.git"
@@ -24,8 +24,8 @@
     "test": "node --test test/*.test.js"
   },
   "dependencies": {
-    "@love-moon/ai-sdk": "0.16.0",
-    "@love-moon/conductor-sdk": "0.16.0",
+    "@love-moon/ai-sdk": "0.17.1",
+    "@love-moon/conductor-sdk": "0.17.1",
     "@github/copilot-sdk": "^0.3.0",
     "chrome-launcher": "^1.2.1",
     "chrome-remote-interface": "^0.33.0",
@@ -38,7 +38,7 @@
   },
   "optionalDependencies": {
     "@roamhq/wrtc": "^0.10.0",
-    "@love-moon/chat-web": "0.16.0"
+    "@love-moon/chat-web": "0.17.1"
   },
   "pnpm": {
     "onlyBuiltDependencies": [

package/src/backend-http.js

@@ -134,13 +134,19 @@ export function createBackendHttp({ config, fetchImpl, env = process.env }) {
     return payload;
   }
 
-  /** GET a binary body; resolves to the raw fetch Response (caller streams it). */
+  /** Fetch a binary body (GET, or POST with `options.body` as JSON); resolves to the raw Response. */
   async function download(pathname, options = {}) {
+    const hasBody = options.body !== undefined;
     let response;
     try {
       response = await doFetch(buildUrl(pathname, options.query), {
-        method: "GET",
-        headers: { Authorization: `Bearer ${config.agentToken}`, Accept: "*/*" },
+        method: hasBody ? "POST" : "GET",
+        headers: {
+          Authorization: `Bearer ${config.agentToken}`,
+          Accept: "*/*",
+          ...(hasBody ? { "Content-Type": "application/json" } : {}),
+        },
+        ...(hasBody ? { body: JSON.stringify(options.body) } : {}),
       });
     } catch (error) {
       throw new BackendHttpError(`Download failed: ${error?.message || String(error)}`, undefined, undefined);

package/src/daemon-update.js

@@ -11,6 +11,7 @@ import {
   detectPackageManager,
   fetchLatestVersion,
   isNewerVersion,
+  resolveBundledNodeDir,
   resolveGlobalInstallPrefix,
 } from "./version-check.js";
 import {
@@ -283,6 +284,8 @@ function buildInstallEnv(packageManager, packageRoot, env) {
     const prefix = resolveGlobalInstallPrefix(packageRoot);
     if (prefix) installEnv.npm_config_prefix = prefix;
   }
+  const nodeDir = resolveBundledNodeDir();
+  if (nodeDir && !installEnv.npm_config_nodedir) installEnv.npm_config_nodedir = nodeDir;
   return installEnv;
 }
 

package/src/daemon.js

@@ -47,6 +47,7 @@ import {
 import { REMOTE_WORKTREE_ENV, remoteWorktreeFireEnv } from "./remote/mcp-launch.js";
 import {
   REMOTE_FILE_CAPABILITY,
+  REMOTE_FILE_PREVIEW_CAPABILITY,
   createRemoteFileHandlers,
   handleRemoteFileRequest,
 } from "./remote-file-handlers.js";
@@ -68,7 +69,7 @@ import {
   normalizeRuntimeBackendAlias,
   normalizeRuntimeBackendName,
 } from "./runtime-backends.js";
-import { resolveClaudeCommandForRoot } from "@love-moon/ai-sdk";
+import { buildClaudeRootSandboxNotice, claudeCommandNeedsRootSandbox } from "@love-moon/ai-sdk";
 import {
   PACKAGE_NAME,
   buildUpgradeCommand,
@@ -573,15 +574,20 @@ export function ensureNodePtySpawnHelperExecutable(deps = {}) {
 }
 
 // A tool-preset PTY task runs the configured allow_cli_list command through a
-// login shell, bypassing ai-sdk entirely. claude refuses to start as root with
-// `--dangerously-skip-permissions`, so rewrite the command the same way the
-// ai-sdk session rewrites its permission mode — one shared root check, so the
-// two paths cannot drift.
-export function resolvePtyToolPresetCommand(cliCommand, env = process.env) {
+// login shell, bypassing ai-sdk entirely. The command is never rewritten: as
+// root without IS_SANDBOX=1, claude refuses `--dangerously-skip-permissions`
+// and exits, so print the same IS_SANDBOX hint the chat path shows, right in
+// the terminal before claude's own error.
+export function resolvePtyToolPresetCommand(cliCommand, env = process.env, options = {}) {
   if (inferBuiltInRuntimeBackendFromCommand(cliCommand) !== "claude") {
     return cliCommand;
   }
-  return resolveClaudeCommandForRoot(cliCommand, env);
+  if (!claudeCommandNeedsRootSandbox(cliCommand, env)) {
+    return cliCommand;
+  }
+  const notice = buildClaudeRootSandboxNotice({ configFile: options.configFile });
+  const quoted = `'${notice.replace(/'/g, "'\\''")}'`;
+  return `printf '%s\\n\\n' ${quoted} >&2; ${cliCommand}`;
 }
 
 export function isSafeTaskWorktreeRoot(projectWorkspacePath, worktreeRoot) {
@@ -989,6 +995,21 @@ function buildPtyTaskEnv(baseEnv = process.env, launchEnv = {}) {
   };
 }
 
+const CLAUDE_ROOT_OPT_OUT_ENV_KEYS = ["IS_SANDBOX", "CLAUDE_CODE_BUBBLEWRAP"];
+
+function pickClaudeRootOptOutEnv(configEnv) {
+  const picked = {};
+  if (!configEnv || typeof configEnv !== "object") {
+    return picked;
+  }
+  for (const key of CLAUDE_ROOT_OPT_OUT_ENV_KEYS) {
+    if (configEnv[key] !== undefined && configEnv[key] !== null) {
+      picked[key] = String(configEnv[key]);
+    }
+  }
+  return picked;
+}
+
 // Module-level so the PTY launch wiring is directly testable: the tool-preset
 // branch has to hand the *child's* env to the root check, and that seam is
 // exactly where a bug hid before (the check read the daemon's own process.env,
@@ -1037,9 +1058,17 @@ export function buildPtyLaunchSpec(launchConfig, fallbackCwd, deps = {}) {
     if (!cliCommand) {
       throw new Error(`Unsupported tool preset: ${toolPreset}`);
     }
-    const launchCommand = resolvePtyToolPresetCommand(cliCommand, buildPtyTaskEnv(baseEnv, env));
+    // The PTY child inherits the daemon env, not the config's `envs:` block,
+    // yet the root hint tells users to set `envs.IS_SANDBOX: "1"`. Forward
+    // just claude's root opt-outs so that advice works for terminal tasks too.
+    // launch_config.env still wins, matching the spawned env.
+    const isClaudePreset = inferBuiltInRuntimeBackendFromCommand(cliCommand) === "claude";
+    const launchEnv = isClaudePreset ? { ...pickClaudeRootOptOutEnv(deps.configEnv), ...env } : env;
+    const launchCommand = resolvePtyToolPresetCommand(cliCommand, buildPtyTaskEnv(baseEnv, launchEnv), {
+      configFile: deps.configFile,
+    });
     if (launchCommand !== cliCommand) {
-      log(`[pty] Adjusted ${toolPreset} command for root: ${launchCommand}`);
+      log(`[pty] ${toolPreset} runs as root without IS_SANDBOX=1; claude will refuse bypassPermissions`);
     }
     return {
       entrypointType,
@@ -1048,7 +1077,7 @@ export function buildPtyLaunchSpec(launchConfig, fallbackCwd, deps = {}) {
       args: ["-lc", launchCommand],
       shell: preferredShell,
       cwd,
-      env,
+      env: launchEnv,
       cols,
       rows,
     };
@@ -3909,7 +3938,7 @@ export function startDaemon(config = {}, deps = {}) {
     log("[remote-exec] Disabled by config (remote_exec: false); capability not advertised");
   }
   if (remoteFileEnabled) {
-    advertisedCapabilities.push(REMOTE_FILE_CAPABILITY);
+    advertisedCapabilities.push(REMOTE_FILE_CAPABILITY, REMOTE_FILE_PREVIEW_CAPABILITY);
   } else {
     log("[remote-file] Disabled by config (remote_file: false); capability not advertised");
   }
@@ -3985,6 +4014,15 @@ export function startDaemon(config = {}, deps = {}) {
         config: sdkConfig,
         agentHost: AGENT_NAME,
         guestRoot: IS_GUEST_DAEMON ? GUEST_ROOT : null,
+        // Every Fire logs to `<task dir>/conductor.log`, so the log path is the
+        // one place the working directory survives a daemon restart (adopted
+        // tmux records carry it too).
+        resolveTaskCwd: (taskId) => {
+          const ptyCwd = activePtySessions.get(taskId)?.cwd;
+          if (ptyCwd) return ptyCwd;
+          const logPath = activeTaskProcesses.get(taskId)?.logPath;
+          return logPath ? path.dirname(logPath) : null;
+        },
       })
     : null;
 
@@ -5554,6 +5592,8 @@ export function startDaemon(config = {}, deps = {}) {
   function resolvePtyLaunchSpec(launchConfig, fallbackCwd) {
     return buildPtyLaunchSpec(launchConfig, fallbackCwd, {
       allowCliList: ALLOW_CLI_LIST,
+      configEnv: userConfig?.envs,
+      configFile: effectiveConfigPath,
       supportedBackends: SUPPORTED_BACKENDS,
       existsSync: existsSyncFn,
       log,

package/src/fire/quota-resume.js

@@ -0,0 +1,313 @@
+/**
+ * Model quota ("session limit") handling for fire.
+ *
+ * When a backend turn fails because the subscription quota is used up, fire
+ * parks the task until the quota resets instead of failing every following
+ * message. The resume itself is a one-off Conductor scheduled message
+ * (`source: "quota_resume"`), so it survives fire/daemon restarts and shows up
+ * in the task's schedule list where a person can cancel it.
+ */
+
+const QUOTA_ERROR_PATTERNS = [
+  /hit your (?:[\w-]+ )?limit/i,
+  /usage limit (?:reached|exceeded)/i,
+  /\b(?:session|5-hour|five-hour|weekly|daily|opus|sonnet) limit\b/i,
+];
+
+const MONTHS = ["jan", "feb", "mar", "apr", "may", "jun", "jul", "aug", "sep", "oct", "nov", "dec"];
+
+const MINUTE_MS = 60_000;
+const HOUR_MS = 60 * MINUTE_MS;
+const DAY_MS = 24 * HOUR_MS;
+
+/** Used when the error names no reset time at all. */
+export const QUOTA_FALLBACK_WAIT_MS = HOUR_MS;
+/** Resume this long after the reset at the earliest, so the quota has really refilled. */
+export const QUOTA_RESUME_MIN_DELAY_MS = MINUTE_MS;
+/** Extra random spread on top, so tasks sharing one subscription do not all start at once. */
+export const QUOTA_RESUME_JITTER_MS = 4 * MINUTE_MS;
+/** Consecutive quota hits on resume before fire stops scheduling more. */
+export const QUOTA_RESUME_MAX_ATTEMPTS = 3;
+
+export const QUOTA_RESUME_PROMPT =
+  "[额度已恢复，自动继续] 模型额度用完时中断了你的工作。请继续中断前未完成的工作。";
+
+export function isQuotaLimitError(message) {
+  const text = String(message || "");
+  return QUOTA_ERROR_PATTERNS.some((pattern) => pattern.test(text));
+}
+
+/**
+ * Recognises a quota error and works out when the quota resets.
+ * Returns null for any other error; `resetAt` is null when the text names no time.
+ */
+export function parseQuotaLimitError(message, { now = new Date(), defaultTimeZone } = {}) {
+  const text = String(message || "");
+  if (!isQuotaLimitError(text)) {
+    return null;
+  }
+  return { resetAt: parseQuotaResetAt(text, { now, defaultTimeZone }) };
+}
+
+export function parseQuotaResetAt(text, { now = new Date(), defaultTimeZone } = {}) {
+  const nowMs = now.getTime();
+
+  // Older Claude Code: "Claude AI usage limit reached|1759561200"
+  const epoch = /limit reached\|(\d{10,13})/i.exec(text);
+  if (epoch) {
+    const value = Number(epoch[1]);
+    return new Date(epoch[1].length === 10 ? value * 1000 : value);
+  }
+
+  // "try again in 2 hours 13 minutes"
+  const relative = /try again in\s+(?:(\d+)\s*(?:hours?|hrs?|h)\b)?\s*(?:(\d+)\s*(?:minutes?|mins?|m)\b)?/i.exec(text);
+  if (relative && (relative[1] || relative[2])) {
+    return new Date(nowMs + Number(relative[1] || 0) * HOUR_MS + Number(relative[2] || 0) * MINUTE_MS);
+  }
+
+  // "resets 1:20am (Asia/Shanghai)", "resets Oct 7, 2am (Asia/Shanghai)", "try again at 3:05 PM"
+  const clock =
+    /(?:resets?|try again at)\s+(?:at\s+)?(?:([A-Za-z]{3,9})\.?\s+(\d{1,2}),?\s+(?:at\s+)?)?(\d{1,2})(?::(\d{2}))?\s*([ap]\.?m\.?)?(?:\s*\(([^)]+)\))?/i.exec(
+      text,
+    );
+  if (!clock) {
+    return null;
+  }
+  const [, monthName, dayText, hourText, minuteText, meridiem, zoneText] = clock;
+  let hour = Number(hourText);
+  const minute = Number(minuteText || 0);
+  if (meridiem) {
+    const pm = meridiem.toLowerCase().startsWith("p");
+    if (hour < 1 || hour > 12) return null;
+    hour = (hour % 12) + (pm ? 12 : 0);
+  }
+  if (hour > 23 || minute > 59) {
+    return null;
+  }
+  const timeZone = resolveTimeZone(zoneText) || resolveTimeZone(defaultTimeZone) || undefined;
+  const today = zonedParts(nowMs, timeZone);
+
+  if (monthName) {
+    const month = MONTHS.indexOf(monthName.slice(0, 3).toLowerCase());
+    if (month < 0) return null;
+    const day = Number(dayText);
+    let resetMs = zonedWallTimeToUtc({ year: today.year, month: month + 1, day, hour, minute }, timeZone);
+    if (resetMs < nowMs - DAY_MS) {
+      resetMs = zonedWallTimeToUtc({ year: today.year + 1, month: month + 1, day, hour, minute }, timeZone);
+    }
+    return new Date(resetMs);
+  }
+
+  let resetMs = zonedWallTimeToUtc({ ...today, hour, minute }, timeZone);
+  if (resetMs <= nowMs - 10 * MINUTE_MS) {
+    // A time-only reset already behind us means tomorrow.
+    resetMs = zonedWallTimeToUtc({ ...today, day: today.day + 1, hour, minute }, timeZone);
+  } else if (resetMs < nowMs) {
+    resetMs = nowMs;
+  }
+  return new Date(resetMs);
+}
+
+/** When to send the resume message: after the reset, plus jitter. */
+export function computeQuotaResumeAt(resetAt, { now = new Date(), random = Math.random } = {}) {
+  const nowMs = now.getTime();
+  const base = resetAt instanceof Date && Number.isFinite(resetAt.getTime())
+    ? resetAt.getTime()
+    : nowMs + QUOTA_FALLBACK_WAIT_MS;
+  const jitter = Math.floor(Math.max(0, Math.min(1, Number(random()) || 0)) * QUOTA_RESUME_JITTER_MS);
+  return new Date(Math.max(base, nowMs) + QUOTA_RESUME_MIN_DELAY_MS + jitter);
+}
+
+/**
+ * The prompt for the resume turn: the resume note plus every message that has
+ * not been handled yet (the one whose turn hit the quota, then those that
+ * arrived while waiting).
+ */
+export function buildQuotaResumePrompt(queued = []) {
+  const parts = [QUOTA_RESUME_PROMPT];
+  const pending = queued.filter((item) => item && String(item.content || "").trim());
+  if (pending.length) {
+    parts.push(`以下 ${pending.length} 条消息还没有处理（按时间顺序）：`);
+    pending.forEach((item, index) => {
+      parts.push(`--- 消息 ${index + 1} ---\n${String(item.content).trim()}`);
+    });
+  }
+  return parts.join("\n\n");
+}
+
+export function isQuotaResumePrompt(content) {
+  return String(content || "").trim().startsWith(QUOTA_RESUME_PROMPT);
+}
+
+const RESUME_ITEM_SEPARATOR = /\n\n--- 消息 \d+ ---\n/;
+
+/**
+ * The pending messages a resume prompt lists (the inverse of
+ * buildQuotaResumePrompt), so a fire that restarted mid-wait can carry them on.
+ */
+export function parseQuotaResumePrompt(content) {
+  const text = String(content || "").trim();
+  if (!isQuotaResumePrompt(text)) {
+    return [];
+  }
+  return text
+    .split(RESUME_ITEM_SEPARATOR)
+    .slice(1)
+    .map((part) => part.trim())
+    .filter(Boolean)
+    .map((part) => ({ messageId: null, content: part }));
+}
+
+/** Concatenates pending-message lists, dropping repeats of the same text. */
+export function mergeQueuedMessages(...lists) {
+  const seen = new Set();
+  const merged = [];
+  for (const item of lists.flat()) {
+    const key = String(item?.content || "").trim();
+    if (!key || seen.has(key)) continue;
+    seen.add(key);
+    merged.push(item);
+  }
+  return merged;
+}
+
+export function formatResumeTime(date, timeZone) {
+  try {
+    return new Intl.DateTimeFormat("zh-CN", {
+      timeZone: resolveTimeZone(timeZone) || undefined,
+      month: "2-digit",
+      day: "2-digit",
+      hour: "2-digit",
+      minute: "2-digit",
+      hourCycle: "h23",
+    }).format(date);
+  } catch {
+    return date.toISOString();
+  }
+}
+
+/**
+ * Creates and cancels the resume schedule through the Conductor HTTP API.
+ * Returns null when fire has no backend URL/token (e.g. a guest daemon).
+ */
+export function createQuotaResumeScheduler({ env = process.env, fetchImpl = globalThis.fetch } = {}) {
+  const backendUrl = typeof env.CONDUCTOR_BACKEND_URL === "string" ? env.CONDUCTOR_BACKEND_URL.trim() : "";
+  const token = typeof env.CONDUCTOR_AGENT_TOKEN === "string" ? env.CONDUCTOR_AGENT_TOKEN.trim() : "";
+  if (!backendUrl || !token || typeof fetchImpl !== "function") {
+    return null;
+  }
+  const base = backendUrl.replace(/\/+$/, "");
+  // No X-Conductor-Actor header: this is fire itself, not the agent, so the
+  // task's agent schedule-access setting must not block it.
+  const headers = {
+    Authorization: `Bearer ${token}`,
+    Accept: "application/json",
+    "Content-Type": "application/json",
+  };
+  const schedulesUrl = (taskId) => `${base}/api/tasks/${encodeURIComponent(taskId)}/scheduled-messages`;
+
+  return {
+    async schedule({ taskId, sendAt, content }) {
+      const response = await fetchImpl(schedulesUrl(taskId), {
+        method: "POST",
+        headers,
+        body: JSON.stringify({
+          content,
+          source: "quota_resume",
+          schedule: { mode: "at", sendAt: sendAt.toISOString() },
+        }),
+      });
+      if (!response.ok) {
+        const detail = await response.text().catch(() => "");
+        throw new Error(`schedule quota resume failed: HTTP ${response.status} ${detail}`.trim());
+      }
+      const body = await response.json().catch(() => ({}));
+      return { id: typeof body?.id === "string" ? body.id : null };
+    },
+    /** Active quota_resume schedules of the task (left behind by an earlier fire). */
+    async listActive({ taskId }) {
+      const response = await fetchImpl(`${schedulesUrl(taskId)}?status=active`, { method: "GET", headers });
+      if (!response.ok) {
+        throw new Error(`list quota resumes failed: HTTP ${response.status}`);
+      }
+      const body = await response.json().catch(() => ({}));
+      const schedules = Array.isArray(body?.schedules) ? body.schedules : [];
+      // Servers before `source` existed: recognise the resume by its text.
+      return schedules.filter((row) =>
+        row?.source ? row.source === "quota_resume" : isQuotaResumePrompt(row?.content),
+      );
+    },
+    async update({ taskId, scheduleId, content }) {
+      const response = await fetchImpl(`${schedulesUrl(taskId)}/${encodeURIComponent(scheduleId)}`, {
+        method: "PATCH",
+        headers,
+        body: JSON.stringify({ content }),
+      });
+      if (!response.ok) {
+        throw new Error(`update quota resume failed: HTTP ${response.status}`);
+      }
+    },
+    async cancel({ taskId, scheduleId }) {
+      // cancel_only: never delete a row the dispatcher already sent (that
+      // would erase its history); a server without the flag still cancels
+      // active rows, and fire only cancels before the send time.
+      const response = await fetchImpl(
+        `${schedulesUrl(taskId)}/${encodeURIComponent(scheduleId)}?cancel_only=1`,
+        { method: "DELETE", headers },
+      );
+      if (!response.ok && response.status !== 404 && response.status !== 409) {
+        throw new Error(`cancel quota resume failed: HTTP ${response.status}`);
+      }
+    },
+  };
+}
+
+function resolveTimeZone(value) {
+  const zone = typeof value === "string" ? value.trim() : "";
+  if (!zone) return null;
+  try {
+    new Intl.DateTimeFormat("en-US", { timeZone: zone });
+    return zone;
+  } catch {
+    return null;
+  }
+}
+
+function zonedParts(ms, timeZone) {
+  const parts = {};
+  for (const part of new Intl.DateTimeFormat("en-US", {
+    timeZone,
+    hourCycle: "h23",
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit",
+    hour: "2-digit",
+    minute: "2-digit",
+    second: "2-digit",
+  }).formatToParts(new Date(ms))) {
+    if (part.type !== "literal") parts[part.type] = Number(part.value);
+  }
+  return {
+    year: parts.year,
+    month: parts.month,
+    day: parts.day,
+    hour: parts.hour === 24 ? 0 : parts.hour,
+    minute: parts.minute,
+    second: parts.second,
+  };
+}
+
+/** Offset of `timeZone` from UTC at instant `ms`, in ms (local minus UTC). */
+function zoneOffsetMs(ms, timeZone) {
+  const p = zonedParts(ms, timeZone);
+  const asUtc = Date.UTC(p.year, p.month - 1, p.day, p.hour, p.minute, p.second);
+  return asUtc - Math.floor(ms / 1000) * 1000;
+}
+
+/** UTC instant of a wall-clock time in `timeZone` (day overflow is normalised). */
+function zonedWallTimeToUtc({ year, month, day, hour, minute }, timeZone) {
+  const guess = Date.UTC(year, month - 1, day, hour, minute, 0);
+  const first = guess - zoneOffsetMs(guess, timeZone);
+  const second = guess - zoneOffsetMs(first, timeZone);
+  return second;
+}

package/src/remote/mcp-launch.js

@@ -139,9 +139,9 @@ export function buildRemoteWorktreeSessionOptions({
         ...(sessionOptions.mcpServers || {}),
         [MCP_SERVER_NAME]: { type: "stdio", command: execPath, args },
       },
-      // Under the default bypassPermissions a root install is downgraded to
-      // acceptEdits, which would deny every remote_* call headless. A mode the
-      // user chose on purpose is left alone rather than widened.
+      // Pre-approve the remote_* tools under the default bypassPermissions so
+      // they keep working if claude ever runs in a prompting mode headless. A
+      // mode the user chose on purpose is left alone rather than widened.
       ...(mode === undefined || mode === "bypassPermissions"
         ? { allowedTools: [...new Set([...allowed, `mcp__${MCP_SERVER_NAME}`])] }
         : {}),