@love-moon/conductor-cli 0.13.1 → 0.13.3

package/CHANGELOG.md

@@ -1,5 +1,85 @@
 # @love-moon/conductor-cli
 
+## 0.13.3
+
+### Patch Changes
+
+- 9858ad5: Fix Update daemon deleting the running install when the upgrade failed. Any
+  failed `npm install -g` (a timeout on a slow registry, a node-gyp error) used to
+  trigger an uninstall plus `rm -rf` of the global package before one retry. When
+  the retry also failed, the daemon kept running with its files gone and every new
+  task died at Fire launch with `MODULE_NOT_FOUND`. The clear-and-retry now only
+  runs on `ENOTEMPTY`, and it moves the old install aside and restores it if the
+  retry fails.
+- Updated dependencies [0859251]
+- Updated dependencies [c1b66d1]
+- Updated dependencies [f6dbd6b]
+  - @love-moon/ai-sdk@0.13.3
+  - @love-moon/conductor-sdk@0.13.3
+
+## 0.13.2
+
+### Patch Changes
+
+- 6547b2c: Add read-only daemon queries and archived-task search to the CLI:
+  `conductor daemon list [--all]` (online daemons, version, AI backends),
+  `conductor daemon tools <host>` (installed AI tools and reachability),
+  `conductor daemon quota <host> [--tool] [--refresh]` (usage windows / balance
+  per tool), and `conductor task list --archived [--search] [--all-projects]
+[--page]`. The SDK's `BackendApiClient` gains `listAgents`,
+  `getAiManagerStatus`, `getAiManagerQuota` and `listAchievedTasks` over the
+  existing web API routes; no server change.
+- 8c2833d: Support `/compact [focus instructions]` in task chats. Fire detects the command
+  per message (like `/goal`), runs the backend's native context compaction
+  instead of sending the text to the model, and posts one confirmation with the
+  token savings. Sessions advertise `capabilities.compact` and implement the new
+  optional `runCompact()`: claude (native `/compact`), codex app-server
+  (`thread/compact/start`), copilot (`session.history.compact`), kimi wire and
+  legacy print (built-in `/compact`), opencode (`session.summarize`) and dsh
+  (summary turn, then a fresh session seeded with the summary). Backends without
+  the capability (chat-web, codex exec, Kimi Code prompt mode) reply with a
+  not-supported notice. Opencode compaction summaries no longer surface as chat
+  replies, and dsh clears its "compacting context" status when automatic
+  compaction ends.
+- c3a55b8: Fix tmux-mode Fire launches that failed before Fire started. The daemon now
+  drops an inherited `TMUX`/`TMUX_PANE` at startup, so a daemon launched from
+  another user's tmux pane (e.g. `su` from root's session) no longer aims every
+  tmux call at that user's socket and fails with `error connecting to
+/tmp/tmux-0/default (Permission denied)`. A launch whose tmux argv would exceed
+  tmux's 16KB command limit (`command too long`), such as a persistent-round
+  prompt with a long summary, now runs through a self-deleting 0600 launch script
+  instead of `bash -c <command>`.
+- 8e3a4c3: Report how many model tokens each turn consumed. After every turn (or `/goal`)
+  `conductor fire` sends the turn's token count (fresh input + cache reads/writes +
+  output) over the new `task_turn_usage` websocket event, and the server adds it
+  to the task's running total shown in the task detail card. A persistent task's
+  total restarts with each round.
+
+  Failed or interrupted turns and `/compact` are counted too; when a turn's usage
+  is unknown the fire reports `null`, which clears the task's last-turn count.
+
+  - `@love-moon/conductor-sdk`: new `ConductorClient.sendTurnUsage(taskId, { tokens })`.
+  - `@love-moon/ai-sdk`: the Codex app-server provider's turn/goal `usage` now
+    carries `turnTotalTokens`, the turn's share of Codex's thread-cumulative total.
+    Claude and Codex turn errors carry the tokens spent before the failure as
+    `error.usage` (Claude sums streamed usage when an interrupted query ends
+    without a result).
+  - Claude and Codex backends are counted; other backends report nothing yet.
+
+- 6989999: `conductor task list --include-moved` also lists tasks moved into the project
+  from other projects (`project_id == P OR second_project_id == P`), with a MOVED
+  column naming the origin/target project. `--json` output now carries
+  `secondProjectId`. The SDK gains `TasksApi.listTasks({ includeMoved })`,
+  `BackendApiClient.listTasks({ projectScope: 'display' })` and
+  `Task/TaskSummary.secondProjectId`; it merges the server's existing real and
+  display scopes, so no server change is needed.
+- Updated dependencies [6547b2c]
+- Updated dependencies [8c2833d]
+- Updated dependencies [8e3a4c3]
+- Updated dependencies [6989999]
+  - @love-moon/conductor-sdk@0.13.2
+  - @love-moon/ai-sdk@0.13.2
+
 ## 0.13.1
 
 ### Patch Changes

package/bin/conductor-daemon-query.js

@@ -0,0 +1,185 @@
+/**
+ * conductor daemon list|tools|quota — read-only queries about daemons.
+ *
+ *   list [--all]                          Online daemons, CLI version, AI backends
+ *   tools <host>                          AI tools installed on a daemon + network
+ *   quota <host> [--tool t] [--refresh]   Usage windows / balance per AI tool
+ *
+ * Dispatched from conductor-daemon.js before any daemon startup logic.
+ */
+
+import process from "node:process";
+
+import yargs from "yargs/yargs";
+
+import { EXIT, buildApis, pad, printJson, printPretty, reportError } from "../src/entity-helpers.js";
+
+export const DAEMON_QUERY_VERBS = new Set(["list", "tools", "quota"]);
+
+// Ephemeral per-task `conductor fire` processes also register as agents.
+const FIRE_HOST_PREFIX = "conductor-fire-";
+
+const WINDOW_LABELS = { fiveHour: "5h", weekly: "weekly", weeklySonnet: "weekly-sonnet" };
+
+function printTable(stream, header, rows) {
+  const widths = header
+    .slice(0, -1)
+    .map((title, i) => Math.max(title.length, ...rows.map((row) => String(row[i]).length)));
+  for (const row of [header, ...rows]) {
+    printPretty(stream, row.map((cell, i) => (i < widths.length ? pad(cell, widths[i]) : cell)).join("  "));
+  }
+}
+
+function formatReset(window) {
+  if (typeof window.resetAt !== "number") return window.resetOnDate ?? "";
+  const date = new Date(window.resetAt * 1000);
+  const two = (n) => String(n).padStart(2, "0");
+  return `${two(date.getMonth() + 1)}-${two(date.getDate())} ${two(date.getHours())}:${two(date.getMinutes())}`;
+}
+
+function formatQuota(quota) {
+  if (!quota || typeof quota !== "object") return "";
+  if (quota.error) {
+    // Provider errors can embed multi-line response bodies; --json keeps the full text.
+    const text = String(quota.error).replace(/\s+/g, " ").trim();
+    return `error: ${text.length > 160 ? `${text.slice(0, 157)}...` : text}`;
+  }
+  const parts = [];
+  for (const [key, window] of Object.entries(quota)) {
+    // Copilot's `primary` duplicates one of its named windows.
+    if (key === "primary" || typeof window?.usedPercent !== "number") continue;
+    const reset = formatReset(window);
+    parts.push(`${WINDOW_LABELS[key] ?? key} ${Math.round(window.usedPercent)}% used${reset ? ` (resets ${reset})` : ""}`);
+  }
+  if (quota.credits?.unlimited) parts.push("credits unlimited");
+  else if (quota.credits?.balance != null) parts.push(`credits ${quota.credits.balance}`);
+  if (quota.primaryBalance) {
+    parts.push(`balance ${quota.primaryBalance.totalBalance} ${quota.primaryBalance.currency}`);
+  }
+  if (quota.overage?.status) {
+    const reason = quota.overage.disabledReason ? ` (${quota.overage.disabledReason})` : "";
+    parts.push(`overage ${quota.overage.status}${reason}`);
+  }
+  return parts.join(" · ") || "(no usage data)";
+}
+
+async function handleList(argv, deps) {
+  const { apiClient } = await buildApis(deps);
+  const agents = (await apiClient.listAgents())
+    .filter((agent) => argv.all || !String(agent.host).startsWith(FIRE_HOST_PREFIX));
+  if (argv.json) {
+    printJson(deps.stdout, agents);
+    return EXIT.OK;
+  }
+  if (agents.length === 0) {
+    printPretty(deps.stdout, "(no daemons online)");
+    return EXIT.OK;
+  }
+  printTable(deps.stdout, ["HOST", "VERSION", "BACKENDS"], agents.map((agent) => [
+    agent.shared ? `${agent.host} (shared by ${agent.ownerLabel})` : agent.host,
+    agent.version ?? "",
+    (agent.supportedBackends ?? []).join(","),
+  ]));
+  return EXIT.OK;
+}
+
+async function handleTools(argv, deps) {
+  const { apiClient } = await buildApis(deps);
+  const status = await apiClient.getAiManagerStatus(argv.host);
+  if (argv.json) {
+    printJson(deps.stdout, status);
+    return EXIT.OK;
+  }
+  const install = status?.install ?? {};
+  const network = status?.network ?? {};
+  printTable(deps.stdout, ["TOOL", "INSTALLED", "VERSION", "NETWORK"], Object.keys(install).map((tool) => {
+    const net = network[tool];
+    const reach = !install[tool]?.installed || !net
+      ? ""
+      : net.reachable
+        ? `ok${net.latencyMs != null ? ` (${net.latencyMs}ms)` : ""}`
+        : `unreachable${net.error ? `: ${net.error}` : ""}`;
+    return [tool, install[tool]?.installed ? "yes" : "no", install[tool]?.version ?? "", reach];
+  }));
+  return EXIT.OK;
+}
+
+async function handleQuota(argv, deps) {
+  const { apiClient } = await buildApis(deps);
+  const quota = await apiClient.getAiManagerQuota(argv.host, {
+    tool: argv.tool,
+    forceRefresh: argv.refresh,
+  });
+  if (argv.json) {
+    printJson(deps.stdout, quota);
+    return EXIT.OK;
+  }
+  const { external, ...tools } = quota ?? {};
+  const entries = [...Object.entries(tools), ...Object.entries(external ?? {})];
+  if (entries.length === 0) {
+    printPretty(deps.stdout, "(no quota data)");
+    return EXIT.OK;
+  }
+  printTable(deps.stdout, ["TOOL", "SOURCE", "QUOTA"], entries.map(([tool, entry]) => [
+    tool,
+    entry?.source ?? "",
+    formatQuota(entry),
+  ]));
+  return EXIT.OK;
+}
+
+export async function main(argvInput, deps = {}) {
+  const stdout = deps.stdout || process.stdout;
+  const stderr = deps.stderr || process.stderr;
+  const consoleErr = { error: (msg) => stderr.write(`${msg}\n`) };
+  const handlerDeps = { ...deps, stdout, stderr, env: deps.env || process.env, cwd: deps.cwd || process.cwd() };
+  let exitCode = EXIT.OK;
+  const run = (handler) => async (argv) => {
+    exitCode = await handler(argv, { ...handlerDeps, configFile: argv.configFile });
+  };
+
+  try {
+    await yargs(argvInput)
+      .scriptName("conductor daemon")
+      .strict()
+      .help()
+      .option("json", { type: "boolean", default: false })
+      .option("config-file", { type: "string", describe: "Path to Conductor config file" })
+      .command(
+        "list",
+        "List online daemons with their CLI version and AI backends",
+        (cmd) => cmd.option("all", {
+          type: "boolean",
+          default: false,
+          describe: `Include ephemeral ${FIRE_HOST_PREFIX}* hosts`,
+        }),
+        run(handleList),
+      )
+      .command(
+        "tools <host>",
+        "Show which AI tools are installed on a daemon and whether they are reachable",
+        (cmd) => cmd.positional("host", { type: "string", describe: "Daemon host name" }),
+        run(handleTools),
+      )
+      .command(
+        "quota <host>",
+        "Show usage windows / balance for each AI tool on a daemon",
+        (cmd) => cmd
+          .positional("host", { type: "string", describe: "Daemon host name" })
+          .option("tool", { type: "string", describe: "Only this tool, e.g. claude or codex" })
+          .option("refresh", { type: "boolean", default: false, describe: "Bypass the daemon's quota cache" }),
+        run(handleQuota),
+      )
+      .demandCommand(1)
+      .fail((msg, err) => {
+        // Throw so the command handler does not run after a validation error
+        // (e.g. a missing <host>); yargs keeps going if fail() returns.
+        if (err) throw err;
+        throw Object.assign(new Error(msg), { code: "ARGS" });
+      })
+      .parseAsync();
+  } catch (err) {
+    exitCode = reportError(consoleErr, err);
+  }
+  return exitCode;
+}

package/bin/conductor-daemon.js

@@ -20,9 +20,19 @@ import {
   describeForceRestartRefusal,
   parseDaemonLockState,
 } from "../src/daemon-lock.js";
+import { DAEMON_QUERY_VERBS, main as runDaemonQuery } from "./conductor-daemon-query.js";
 
 const argv = hideBin(process.argv);
 
+// `conductor daemon list|tools|quota` are read-only queries, not a daemon launch.
+// Exit (so startup below never runs) only after stdout drains: a piped
+// --json payload over 64KB would otherwise be cut off.
+if (DAEMON_QUERY_VERBS.has(argv[0])) {
+  const code = await runDaemonQuery(argv);
+  await new Promise((resolve) => process.stdout.write("", resolve));
+  process.exit(code);
+}
+
 const CLI_NAME = process.env.CONDUCTOR_CLI_NAME || "conductor-daemon";
 const CONDUCTOR_HOME = resolveConductorHome();
 
@@ -170,6 +180,7 @@ const args = yargs(argv)
   .example(`$0 --config-file ${resolveConductorConfigPath()}`, "Run with daemon_name from config")
   .example("$0 --nohup", "Run daemon in background with logfile")
   .example("$0 --nohup --force", "Restart daemon in background by stopping the existing one")
+  .example("$0 list | tools <host> | quota <host>", "Query online daemons, their AI tools and quota")
   .help()
   .strict()
   .parse();

package/bin/conductor-fire.js

@@ -1581,6 +1581,43 @@ export function parseGoalDirectiveFromMessage(content) {
   return objective ? { objective } : null;
 }
 
+/**
+ * Per-message `/compact` detector: first non-empty line is `/compact`
+ * (case-insensitive), optionally followed by focus instructions; any remaining
+ * lines are appended to them. Returns null when there is no directive.
+ */
+export function parseCompactDirectiveFromMessage(content) {
+  if (typeof content !== "string") {
+    return null;
+  }
+  const lines = content.split("\n");
+  let i = 0;
+  while (i < lines.length && lines[i].trim() === "") {
+    i += 1;
+  }
+  const match = i < lines.length ? lines[i].trim().match(/^\/compact(?:\s+(.*))?$/i) : null;
+  if (!match) {
+    return null;
+  }
+  const rest = lines.slice(i + 1).join("\n").trim();
+  return { instructions: [(match[1] || "").trim(), rest].filter(Boolean).join("\n\n") };
+}
+
+export function formatCompactReply(backendName, compact, instructions = "") {
+  if (compact?.status !== "compacted") {
+    return `${backendName} 当前没有可压缩的上下文。`;
+  }
+  const count = (value) => Number(value).toLocaleString("en-US");
+  const detail =
+    Number.isFinite(compact.preTokens) && Number.isFinite(compact.postTokens)
+      ? `（约 ${count(compact.preTokens)} → ${count(compact.postTokens)} tokens）`
+      : Number.isFinite(compact.tokensRemoved)
+        ? `（释放约 ${count(compact.tokensRemoved)} tokens）`
+        : "";
+  const ignored = instructions && !compact.instructionsApplied ? `\n${backendName} 不支持压缩附加说明，已忽略。` : "";
+  return `${backendName} 上下文已压缩${detail}。${ignored}`;
+}
+
 export function injectResolvedTaskId(taskId, env = process.env) {
   const normalizedTaskId = normalizeTaskId(taskId);
   if (!normalizedTaskId) {
@@ -3340,6 +3377,7 @@ export class BridgeRunner {
         useInitialImages,
         media,
         contextFiles,
+        replyTo,
         onProgress: (payload) => {
           void this.reportRuntimeStatus(payload, replyTo);
         },
@@ -3547,10 +3585,17 @@ export class BridgeRunner {
       // best-effort
     }
 
+    const compactDirective = hasAttachmentInputs ? null : parseCompactDirectiveFromMessage(content);
+    if (compactDirective) {
+      return this.runCompactCommand(compactDirective, options);
+    }
+
     if (willRunGoal) {
-      const goalResult = await this.backendSession.runGoal(
-        { objective: goalDirective.objective, source: { type: "manual" } },
-        options,
+      const goalResult = await this.runWithTurnUsage(() =>
+        this.backendSession.runGoal(
+          { objective: goalDirective.objective, source: { type: "manual" } },
+          options,
+        ),
       );
       // Goal SDK is expected to return `{ text, goal, usage, metadata }`. We
       // normalize back into the runTurn-compatible shape downstream consumers
@@ -3567,7 +3612,81 @@ export class BridgeRunner {
         },
       };
     }
-    return this.backendSession.runTurn(content, options);
+    return this.runWithTurnUsage(() => this.backendSession.runTurn(content, options));
+  }
+
+  /** Runs one backend turn and reports its token count, including failed or interrupted turns. */
+  async runWithTurnUsage(runTurn) {
+    let result;
+    try {
+      result = await runTurn();
+    } catch (error) {
+      this.reportTurnUsage(error?.usage, { failed: true });
+      throw error;
+    }
+    this.reportTurnUsage(result?.usage);
+    return result;
+  }
+
+  /**
+   * Best-effort: report a turn's token count to the server. A failed turn with
+   * unknown usage reports `null` so the task card drops the previous turn's count.
+   */
+  reportTurnUsage(usage, { failed = false } = {}) {
+    const tokens = countTurnTokens(usage);
+    if ((tokens === null && !failed) || typeof this.conductor?.sendTurnUsage !== "function") {
+      return;
+    }
+    Promise.resolve()
+      .then(() => this.conductor.sendTurnUsage(this.taskId, { tokens }))
+      .catch((error) => {
+        log(`Failed to report turn usage: ${error?.message || error}`);
+      });
+  }
+
+  /**
+   * `/compact`: compact the backend's context instead of sending the message
+   * to the model. Providers stay silent while compacting, so fire posts the
+   * single confirmation itself; backends without the capability get a notice
+   * rather than having `/compact` forwarded as prose.
+   */
+  async runCompactCommand({ instructions }, { onProgress, replyTo = "" } = {}) {
+    const snapshot =
+      typeof this.backendSession?.getSnapshot === "function" ? this.backendSession.getSnapshot() : null;
+    const compactCapable =
+      snapshot?.capabilities?.compact === true && typeof this.backendSession?.runCompact === "function";
+    let result = null;
+    let text;
+    if (compactCapable) {
+      onProgress?.({
+        phase: "context_compaction",
+        reply_in_progress: true,
+        status_line: `${this.backendName} compacting context`,
+      });
+      result = await this.runWithTurnUsage(() => this.backendSession.runCompact({ instructions }, { onProgress }));
+      text = formatCompactReply(this.backendName, result?.compact, instructions);
+    } else {
+      text = `${this.backendName} 不支持 /compact，未执行压缩。`;
+    }
+    // Fire owns this reply, so it also settles the status: providers' noop
+    // paths return without emitting any progress of their own.
+    onProgress?.({ phase: "turn_completed", reply_in_progress: false, status_done_line: text });
+    log(`[compact] backend=${this.backendName} capable=${compactCapable} status=${result?.compact?.status || "unsupported"}`);
+    if (this.useSessionFileReplyStream && !this.stopped) {
+      try {
+        await this.sendSessionStreamMessage({ text, replyTo });
+      } catch (error) {
+        log(`[compact] failed to post confirmation: ${error?.message || error}`);
+      }
+    }
+    return {
+      text,
+      items: [],
+      usage: result?.usage || null,
+      provider: this.backendName,
+      events: [],
+      metadata: { ...(result?.metadata || {}), compact: result?.compact || null },
+    };
   }
 
   async handlePrePromptMessage(content) {
@@ -3637,6 +3756,7 @@ export class BridgeRunner {
     try {
       const result = await this.dispatchBackendTurn(content, {
         useInitialImages: Boolean(includeImages),
+        replyTo: replyTarget,
         onProgress: (payload) => {
           void this.reportRuntimeStatus(payload, replyTarget);
         },
@@ -3752,6 +3872,24 @@ function log(message) {
   appendFireLocalLog(line);
 }
 
+/**
+ * Tokens one turn consumed: everything the model read (fresh input plus cache
+ * reads/writes) and wrote. Claude reports per-turn usage; the Codex provider
+ * derives `turnTotalTokens` from thread totals. Other shapes → null.
+ */
+export function countTurnTokens(usage) {
+  if (!usage || typeof usage !== "object") {
+    return null;
+  }
+  if (Number.isFinite(usage.turnTotalTokens)) {
+    return usage.turnTotalTokens;
+  }
+  const counts = ["input_tokens", "cache_creation_input_tokens", "cache_read_input_tokens", "output_tokens"]
+    .map((key) => Number(usage[key]))
+    .filter(Number.isFinite);
+  return counts.length > 0 ? counts.reduce((sum, count) => sum + count, 0) : null;
+}
+
 function logBackendReply(backend, text, { usage, replyTo }) {
   const usageSuffix = usage?.total_tokens ? ` (tokens: ${usage.total_tokens})` : "";
   log(`${backend} reply (${replyTo}): ${text}${usageSuffix}`);

package/bin/conductor-task.js

@@ -4,7 +4,8 @@
  * conductor task — entity-oriented task management.
  *
  * Subcommands:
- *   list [--project ...] [--issue <id>] [--status ...]
+ *   list [--project ...] [--issue <id>] [--status ...] [--include-moved]
+ *   list --archived [--search <text>] [--all-projects] [--page N]
  *   create --title <title> [--prompt <prompt>] [--backend <backend>]
  *          [--parent-task-id <id>] [--project ...]
  *   show <id>
@@ -59,6 +60,7 @@ function taskAsObject(task) {
   return {
     id: task.id,
     projectId: task.projectId,
+    secondProjectId: task.secondProjectId ?? null,
     issueId: task.issueId ?? null,
     title: task.title,
     status: task.status,
@@ -220,13 +222,83 @@ function formatContentPreview(value) {
   return `${text.slice(0, 57)}...`;
 }
 
+// "from <project>" for tasks moved into `projectId`, "to <project>" for tasks
+// moved out of it, "" otherwise. Project names are only fetched when needed.
+async function buildMovedLabels(apis, projectId, tasks) {
+  const moved = tasks.map((task) => {
+    if (task.secondProjectId === projectId && task.projectId !== projectId) {
+      return { dir: "from", id: task.projectId };
+    }
+    if (task.projectId === projectId && task.secondProjectId && task.secondProjectId !== projectId) {
+      return { dir: "to", id: task.secondProjectId };
+    }
+    return null;
+  });
+  const names = new Map();
+  if (moved.some(Boolean)) {
+    for (const p of await apis.projects.listProjects({ includeHidden: true })) {
+      names.set(p.id, p.daemonHost ? `${p.name ?? p.id}@${p.daemonHost}` : (p.name ?? p.id));
+    }
+  }
+  return moved.map((m) => (m ? `${m.dir} ${names.get(m.id) ?? m.id}` : ""));
+}
+
+// Archived (achieved) tasks come from a separate search endpoint: 10 per page,
+// matched against title and transcript, newest-archived first.
+async function handleArchivedList(argv, deps, apis) {
+  const project = argv.allProjects
+    ? null
+    : await resolveProject(apis, { env: deps.env, cwd: deps.cwd, project: argv.project });
+  const result = await apis.apiClient.listAchievedTasks({
+    query: argv.search,
+    projectId: project?.id,
+    page: argv.page,
+  });
+  if (argv.json) {
+    printJson(deps.stdout, result);
+    return EXIT.OK;
+  }
+  if (result.tasks.length === 0) {
+    printPretty(deps.stdout, "(no archived tasks)");
+    return EXIT.OK;
+  }
+  const projectWidth = Math.max(7, ...result.tasks.map((task) => String(task.projectName ?? "").length));
+  printPretty(deps.stdout, `${pad("ID", 36)} ${pad("ARCHIVED", 10)} ${pad("PROJECT", projectWidth)} TITLE`);
+  for (const task of result.tasks) {
+    printPretty(
+      deps.stdout,
+      `${pad(task.id, 36)} ${pad(String(task.achievedAt ?? "").slice(0, 10), 10)} ${pad(task.projectName ?? "", projectWidth)} ${task.title ?? ""}`,
+    );
+    if (task.snippet) printPretty(deps.stdout, `    ${task.snippet}`);
+  }
+  if (result.totalPages > 1) {
+    printPretty(deps.stdout, `Page ${result.page}/${result.totalPages} (${result.total} archived tasks); use --page for more.`);
+  }
+  return EXIT.OK;
+}
+
 async function handleList(argv, deps) {
+  // Validated here rather than with yargs implies/conflicts: those count the
+  // boolean defaults as "set", and the parser's fail() does not stop the handler.
+  let argsProblem = null;
+  if (!argv.archived && (argv.search !== undefined || argv.allProjects || argv.page !== undefined)) {
+    argsProblem = "--search, --all-projects and --page require --archived";
+  } else if (argv.archived && (argv.issue || argv.status || argv.includeMoved || (argv.allProjects && argv.project))) {
+    argsProblem = "--archived cannot be combined with --issue, --status, --include-moved, or --project with --all-projects";
+  }
+  if (argsProblem) {
+    const err = new Error(argsProblem);
+    err.code = "ARGS";
+    throw err;
+  }
   const apis = await buildApis(deps);
+  if (argv.archived) return handleArchivedList(argv, deps, apis);
   const project = await resolveProject(apis, { env: deps.env, cwd: deps.cwd, project: argv.project });
   const list = await apis.tasks.listTasks({
     projectId: project.id,
     issueId: argv.issue ? String(argv.issue) : undefined,
     status: parseStatusList(argv.status),
+    includeMoved: argv.includeMoved,
   });
   const objects = (Array.isArray(list) ? list : []).map(taskAsObject);
   if (argv.json) {
@@ -237,13 +309,16 @@ async function handleList(argv, deps) {
     printPretty(deps.stdout, "(no tasks)");
     return EXIT.OK;
   }
-  printPretty(deps.stdout, `${pad("ID", 24)} ${pad("STATUS", 12)} TITLE`);
-  for (const task of objects) {
+  const movedLabels = argv.includeMoved ? await buildMovedLabels(apis, project.id, objects) : null;
+  const movedWidth = movedLabels ? Math.max(5, ...movedLabels.map((label) => label.length)) : 0;
+  const movedCol = (label) => (movedLabels ? `${pad(label, movedWidth)} ` : "");
+  printPretty(deps.stdout, `${pad("ID", 24)} ${pad("STATUS", 12)} ${movedCol("MOVED")}TITLE`);
+  objects.forEach((task, i) => {
     printPretty(
       deps.stdout,
-      `${pad(task.id, 24)} ${pad(task.status, 12)} ${task.title ?? ""}`,
+      `${pad(task.id, 24)} ${pad(task.status, 12)} ${movedCol(movedLabels?.[i] ?? "")}${task.title ?? ""}`,
     );
-  }
+  });
   return EXIT.OK;
 }
 
@@ -571,7 +646,16 @@ export async function main(argvInput = hideBin(process.argv), deps = {}) {
         "List tasks in a project",
         (cmd) => cmd
           .option("issue", { type: "string", describe: "Filter by linked issue id" })
-          .option("status", { type: "string", describe: "Comma-separated status filter" }),
+          .option("status", { type: "string", describe: "Comma-separated status filter" })
+          .option("include-moved", {
+            type: "boolean",
+            default: false,
+            describe: "Also list tasks moved into this project from other projects (adds a MOVED column)",
+          })
+          .option("archived", { type: "boolean", describe: "List archived tasks instead of active ones" })
+          .option("search", { type: "string", describe: "With --archived: match title or transcript text" })
+          .option("all-projects", { type: "boolean", describe: "With --archived: search every project" })
+          .option("page", { type: "number", describe: "With --archived: result page (10 per page)" }),
         async (argv) => {
           exitCode = await handleList(argv, { ...handlerDeps, configFile: argv.configFile });
         },

package/bin/conductor.js

@@ -127,7 +127,7 @@ Usage: conductor <subcommand> [options]
 
 Subcommands:
   fire      Run AI coding agents with Conductor integration
-  daemon    Start long-running daemon for task orchestration
+  daemon    Start long-running daemon (or: daemon list/tools/quota to query daemons)
   config    Interactive configuration setup
   update    Update the CLI to the latest version
   diagnose  Diagnose a task and print likely root cause
@@ -151,6 +151,7 @@ Examples:
   conductor fire -- "fix the bug"
   conductor fire --backend claude -- "add feature"
   conductor daemon --config-file ~/.conductor/config.yaml
+  conductor daemon quota macmini --tool claude
   conductor diagnose <task-id>
   conductor send-file ./screenshot.png
   conductor channel connect feishu

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@love-moon/conductor-cli",
-  "version": "0.13.1",
-  "gitCommitId": "b82ba1c",
+  "version": "0.13.3",
+  "gitCommitId": "d61c070",
   "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.13.1",
-    "@love-moon/conductor-sdk": "0.13.1",
+    "@love-moon/ai-sdk": "0.13.3",
+    "@love-moon/conductor-sdk": "0.13.3",
     "@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.13.1"
+    "@love-moon/chat-web": "0.13.3"
   },
   "pnpm": {
     "onlyBuiltDependencies": [

package/src/daemon-update.js

@@ -272,17 +272,6 @@ function buildInstallCommand(packageManager, pkgSpec) {
   }
 }
 
-function buildUninstallCommand(packageManager, packageName) {
-  switch (packageManager) {
-    case "pnpm":
-      return { command: "pnpm", args: ["remove", "-g", packageName] };
-    case "yarn":
-      return { command: "yarn", args: ["global", "remove", packageName] };
-    default:
-      return { command: "npm", args: ["uninstall", "-g", packageName] };
-  }
-}
-
 /**
  * `npm install -g` targets whichever npm wins the PATH lookup, which is not
  * necessarily the one that installed us. Pin it to the prefix the running
@@ -320,6 +309,7 @@ export async function runDaemonUpdate(params = {}, deps = {}) {
   const killFn = deps.kill || process.kill.bind(process);
   const readFileSync = deps.readFileSync || fs.readFileSync;
   const rmSync = deps.rmSync || fs.rmSync;
+  const renameSync = deps.renameSync || fs.renameSync;
   const sleep = deps.sleep || ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
   const now = deps.now || (() => Date.now());
   const writeStatus = deps.writeStatus || writeDaemonUpdateStatus;
@@ -422,25 +412,43 @@ export async function runDaemonUpdate(params = {}, deps = {}) {
 
   log(`${install.command} ${install.args.join(" ")}`);
   let installResult = await runInstall();
-  if (!installResult.success) {
-    // A half-removed global install makes npm fail with ENOTEMPTY forever.
-    // Clear it out and try once more before giving up.
-    log(`install failed (exit ${installResult.code}); removing the broken install and retrying`);
+  // A half-removed global install makes npm fail with ENOTEMPTY forever. Move
+  // it aside and try once more. Any other failure (timeout, network, build)
+  // leaves the install untouched: the daemon and every fire it spawns run
+  // from that directory.
+  if (!installResult.success && /ENOTEMPTY/.test(`${installResult.stderr}${installResult.stdout}`)) {
+    log(`install failed (exit ${installResult.code}); moving the broken install aside and retrying`);
     log(String(installResult.stderr || installResult.stdout || "").trim().slice(-800));
-    const uninstall = buildUninstallCommand(packageManager, packageName);
-    await runCommand(uninstall.command, uninstall.args, { env: installEnv, timeoutMs: INSTALL_TIMEOUT_MS });
+    let packageDirectory = null;
+    let backupDirectory = null;
     try {
-      const packageDirectory = await resolveGlobalPackageDirectory({
+      packageDirectory = await resolveGlobalPackageDirectory({
         packageManager,
         packageName,
         runCommand: (command, args, options) => runCommand(command, args, { env: installEnv, ...options }),
       });
-      rmSync(packageDirectory, { recursive: true, force: true });
-      log(`removed ${packageDirectory}`);
+      const backup = path.join(path.dirname(packageDirectory), `.${path.basename(packageDirectory)}-update-backup`);
+      rmSync(backup, { recursive: true, force: true });
+      renameSync(packageDirectory, backup);
+      backupDirectory = backup;
+      log(`moved ${packageDirectory} aside`);
     } catch (error) {
-      log(`could not remove the global package directory: ${error?.message || error}`);
+      log(`could not move the global package directory aside: ${error?.message || error}`);
     }
     installResult = await runInstall();
+    if (backupDirectory) {
+      try {
+        if (installResult.success) {
+          rmSync(backupDirectory, { recursive: true, force: true });
+        } else {
+          rmSync(packageDirectory, { recursive: true, force: true });
+          renameSync(backupDirectory, packageDirectory);
+          log(`restored ${packageDirectory}`);
+        }
+      } catch (error) {
+        log(`could not clean up ${backupDirectory}: ${error?.message || error}`);
+      }
+    }
   }
   if (!installResult.success) {
     return fail(

package/src/daemon.js

@@ -1188,6 +1188,13 @@ export function startDaemon(config = {}, deps = {}) {
   // below after we verify tmux is installed; if tmux is missing we log a
   // warning and silently fall back to direct spawn rather than failing every
   // create_task with ENOENT.
+  //
+  // The daemon is not inside any tmux pane, so drop the launching shell's
+  // TMUX/TMUX_PANE: tmux prefers $TMUX over the per-uid default socket, and a
+  // daemon started via `su` from root's tmux pointed every spawn/probe/kill at
+  // /tmp/tmux-0/default ("Permission denied").
+  delete process.env.TMUX;
+  delete process.env.TMUX_PANE;
   const FIRE_TMUX_MODE_ENABLED = getFireTmuxModeEnabled(userConfig);
   // RFC 0035: a guest daemon runs on someone else's machine as a different
   // account. It keeps the ordinary daemon code path but drops the capabilities
@@ -1625,6 +1632,9 @@ export function startDaemon(config = {}, deps = {}) {
     return { attach, append, tail };
   }
 
+  // Headroom under tmux's 16384-byte imsg limit for a client command's argv.
+  const TMUX_ARGV_BYTE_BUDGET = 12 * 1024;
+
   // Spawn the Fire CLI either directly (default) or inside a detached tmux
   // session (when FIRE_TMUX_MODE_ACTIVE). In tmux mode the returned `child`
   // is the short-lived `tmux new-session` client; once it exits with code 0
@@ -1740,7 +1750,21 @@ export function startDaemon(config = {}, deps = {}) {
       "-c",
       shellCommand,
     ];
-    log(`Spawning Fire via tmux: session=${sessionName} cwd=${cwd}`);
+    // tmux rejects a command whose argv exceeds its 16KB message limit
+    // ("command too long"). The -e flags alone can take ~8KB on GPU hosts, so
+    // a long prompt (e.g. a persistent-round summary) no longer fits: hand
+    // bash a self-deleting 0600 script instead of `-c <command>`.
+    let launchScriptPath = "";
+    if (tmuxArgs.reduce((n, arg) => n + Buffer.byteLength(arg) + 1, 0) > TMUX_ARGV_BYTE_BUDGET) {
+      launchScriptPath = path.join(FIRE_SESSION_REGISTRY_DIR, `${sessionName}.sh`);
+      mkdirSyncFn(FIRE_SESSION_REGISTRY_DIR, { recursive: true });
+      writeFileSyncFn(launchScriptPath, `rm -f -- "$0"\n${shellCommand}\n`, { mode: 0o600 });
+      tmuxArgs.splice(-2, 2, launchScriptPath);
+    }
+    log(
+      `Spawning Fire via tmux: session=${sessionName} cwd=${cwd}` +
+        (launchScriptPath ? ` script=${launchScriptPath}` : ""),
+    );
     const child = spawnFn("tmux", tmuxArgs, {
       cwd,
       env,
@@ -1750,6 +1774,18 @@ export function startDaemon(config = {}, deps = {}) {
     if (typeof child.unref === "function") {
       child.unref();
     }
+    if (launchScriptPath) {
+      // Without a session nothing will run (and delete) the script.
+      const removeLaunchScript = () => {
+        try {
+          unlinkSyncFn(launchScriptPath);
+        } catch {
+          // already gone
+        }
+      };
+      child.once("exit", (code) => code !== 0 && removeLaunchScript());
+      child.once("error", removeLaunchScript);
+    }
     return { child, tmuxSession: sessionName, exitMarkerToken };
   }