@love-moon/conductor-cli 0.15.2 → 0.16.0

package/CHANGELOG.md

@@ -1,5 +1,86 @@
 # @love-moon/conductor-cli
 
+## 0.16.0
+
+### Minor Changes
+
+- 0495b79: The CLI can now do what the web app can:
+
+  - `conductor task`: `stop`, `interrupt`, `restart`, `delete`, `archive`/`unarchive`,
+    `rename`, `pin`/`unpin`, `move`, `labels`, `share`/`unshare`, `persistent`,
+    `round start|end`, `cleanup-worktree`, `terminal open|show|close`, `resume`,
+    `attachment download`, `shared <token|link>` (read a shared task), `transcribe <audio>`
+    (speech to text), and `schedule update`. `create` also takes `--daemon-host`, `--agent` (multi-agent group),
+    `--global-backend`, `--worktree`, `--remote-worktree` and `--persistent`.
+    `send --attach` uploads files, `messages --follow` streams new messages, and
+    `list --all-projects` / `--project-ids` lists tasks across projects.
+  - `conductor project`: `update`, `refresh`, `delete`, `reorder`, `agents`,
+    `collab invite|show-invite|join|leave`, `labels list|add|rename|remove`.
+  - `conductor issue`: `delete`, and `list --all-projects` / `--project-ids`.
+  - `conductor daemon`: `restart`, `upgrade [--status|--wait]`, `sessions`, `accounts`,
+    `switch-account`, `commands list|run|status`, `share create|list|revoke|show-invite|accept`.
+  - New `conductor search`, `conductor settings` (global backends, catchphrases, daily
+    report, task-list and card-group preferences, generated reports) and `conductor auth`
+    (`whoami`, `tokens list|create|revoke`).
+
+  Fix: `conductor project hide/unhide` (and the SDK's `setProjectHidden`) no longer erase
+  the project's metadata (task labels, memos, binding data).
+
+  On a cross-daemon merged project, `project hide/unhide`, `delete` and
+  `update --merge-opt-out` act on every daemon, like the web. `hide/unhide --json`
+  still prints the target project, plus `ids` for every project changed.
+  `delete --daemon-host <h>` deletes only that copy; a group delete stops at the
+  first failure and says which ids were deleted. `update --merge-opt-out` lists the
+  same-name projects it also split or re-merged.
+
+- b68fadf: `conductor issue` now matches the web issue board:
+  `start --daemon <host> [--project <id>]` picks the daemon, or the merged-group
+  sibling project, that the task runs on (on another member's shared project the
+  server decides). `--priority` takes `P0|P1|P2`, and `--status` uses
+  `todo|doing|done`; `create` no longer offers `doing`. `list --status` is sent to
+  the server and still applied locally, so an older server that ignores it filters
+  too. An invalid argument now exits 2 without sending a request. The SDK's
+  `updateIssue` forwards `projectId`, and `listIssues` sends multiple statuses to
+  the server and filters the result the same way.
+
+  The matching web server changes (metadata patches merge instead of replacing,
+  `GET /api/issues?status=` filtering) should be deployed before publishing.
+
+- 7c45a56: `conductor issue start` can pick the AI for the task it spawns: `--backend <b>`,
+  or `--global-backend <backend>@<host>` to run the AI on one of your global AI
+  backends while the code stays on the project's daemon (same as the web "Move
+  Issue To Doing" dialog). The SDK's `updateIssue` forwards `globalBackend`.
+
+  Requires a Conductor web server that ships issue global backends (the same
+  release): deploy the web server before publishing the CLI/SDK. An older server
+  ignores `--global-backend` and starts a plain task on the project's daemon; the
+  CLI then prints a warning instead of failing silently.
+
+### Patch Changes
+
+- 5c81d06: Claude turns that wait on background subagents now report their full token
+  usage. Such a turn emits one result per segment and the task card used to show
+  only the last segment; it now sums the result's `modelUsage`, which covers
+  every segment, every subagent and small side calls. `conductor serve-ai`'s
+  `prompt_tokens` / `completion_tokens` come from the same usage, so they now
+  include those too. A turn cut off after an earlier segment keeps that
+  segment's usage.
+- b69d665: Codex turns that spawn sub-agents now include the sub-agents' tokens in the
+  turn usage. Their `thread/tokenUsage/updated` notifications carry the
+  sub-agent's own thread id and were dropped with its other events. A
+  sub-agent's replayed total is not counted, and whatever it spends after the
+  parent turn ends goes to the next turn.
+- 1423475: `conductor task persistent` takes `--auto-end-round` / `--no-auto-end-round`. Persistent
+  tasks now end the current round automatically (asking the AI for its summary, like
+  End round) after an hour without a reply; on by default.
+- Updated dependencies [5c81d06]
+- Updated dependencies [0495b79]
+- Updated dependencies [b69d665]
+- Updated dependencies [b68fadf]
+- Updated dependencies [7c45a56]
+  - @love-moon/ai-sdk@0.16.0
+  - @love-moon/conductor-sdk@0.16.0
+
 ## 0.15.2
 
 ### Patch Changes

package/bin/conductor-auth.js

@@ -0,0 +1,162 @@
+#!/usr/bin/env node
+
+/**
+ * conductor auth — who am I, and the API tokens shown on the web settings page.
+ *
+ * Subcommands:
+ *   whoami                     GET  /api/auth/me                       -> { user: { id, email, phone, tokenScope } }
+ *   tokens list                GET  /api/auth/tokens                   -> [{ id, name, token_prefix, created_at, last_used_at }]
+ *   tokens create [--name N]   POST /api/auth/tokens { name }          -> { token, tokenId, tokenPrefix, createdAt }
+ *   tokens revoke <tokenId>    POST /api/auth/tokens/:tokenId/revoke   -> 204
+ *
+ * `tokens create` prints the raw token once (the server never lists it again).
+ * Login / register / OAuth are intentionally not here: `conductor config`
+ * handles signing in.
+ *
+ * Global flags: --json, --dry-run (write verbs), --config-file.
+ */
+
+import path from "node:path";
+import process from "node:process";
+import { fileURLToPath } from "node:url";
+
+import yargs from "yargs/yargs";
+import { hideBin } from "yargs/helpers";
+
+import { EXIT, exitCodeForError, printJson, printPretty, reportError } from "../src/entity-helpers.js";
+import { apiPath, buildHttp, formatTable, sendOrPreview } from "../src/backend-http.js";
+
+const isMainModule = (() => {
+  const currentFile = fileURLToPath(import.meta.url);
+  const entryFile = process.argv[1] ? path.resolve(process.argv[1]) : "";
+  return entryFile === currentFile;
+})();
+
+const DEFAULT_TOKEN_NAME = "cli";
+
+async function handleWhoami(argv, deps) {
+  const http = await buildHttp(deps);
+  const result = await http.get(apiPath("auth", "me"));
+  if (argv.json) {
+    printJson(deps.stdout, result);
+    return EXIT.OK;
+  }
+  const user = result?.user ?? {};
+  printPretty(deps.stdout, `id:      ${user.id ?? ""}`);
+  if (user.email) printPretty(deps.stdout, `email:   ${user.email}`);
+  if (user.phone) printPretty(deps.stdout, `phone:   ${user.phone}`);
+  if (user.tokenScope) printPretty(deps.stdout, `scope:   ${user.tokenScope}`);
+  printPretty(deps.stdout, `backend: ${http.baseUrl}`);
+  return EXIT.OK;
+}
+
+async function handleTokensList(argv, deps) {
+  const http = await buildHttp(deps);
+  const result = await http.get(apiPath("auth", "tokens"));
+  if (argv.json) {
+    printJson(deps.stdout, result);
+    return EXIT.OK;
+  }
+  const tokens = Array.isArray(result) ? result : [];
+  if (tokens.length === 0) {
+    printPretty(deps.stdout, "(no tokens)");
+    return EXIT.OK;
+  }
+  const rows = tokens.map((token) => [
+    token.id, token.token_prefix ?? "", token.created_at ?? "", token.last_used_at ?? "-", token.name ?? "",
+  ]);
+  for (const line of formatTable(["ID", "PREFIX", "CREATED", "LAST USED", "NAME"], rows)) {
+    printPretty(deps.stdout, line);
+  }
+  return EXIT.OK;
+}
+
+async function handleTokensCreate(argv, deps) {
+  const http = await buildHttp(deps);
+  const body = { name: String(argv.name ?? DEFAULT_TOKEN_NAME) };
+  const { dryRun, data } = await sendOrPreview(http, argv, deps, "POST", apiPath("auth", "tokens"), body);
+  if (dryRun) return EXIT.OK;
+  deps.stderr.write("Warning: this token is shown only once. Store it somewhere safe now.\n");
+  if (argv.json) {
+    printJson(deps.stdout, data);
+    return EXIT.OK;
+  }
+  printPretty(deps.stdout, `Created token ${data?.tokenId ?? ""} (${body.name}, prefix ${data?.tokenPrefix ?? ""})`);
+  printPretty(deps.stdout, `token: ${data?.token ?? ""}`);
+  return EXIT.OK;
+}
+
+async function handleTokensRevoke(argv, deps) {
+  const http = await buildHttp(deps);
+  const tokenId = String(argv.tokenId);
+  const { dryRun } = await sendOrPreview(
+    http, argv, deps, "POST", apiPath("auth", "tokens", tokenId, "revoke"), undefined,
+  );
+  if (dryRun) return EXIT.OK;
+  if (argv.json) {
+    printJson(deps.stdout, { revoked: true, tokenId });
+    return EXIT.OK;
+  }
+  printPretty(deps.stdout, `Revoked token ${tokenId}`);
+  return EXIT.OK;
+}
+
+export async function main(argvInput = hideBin(process.argv), deps = {}) {
+  const stdout = deps.stdout || process.stdout;
+  const stderr = deps.stderr || process.stderr;
+  const env = deps.env || process.env;
+  const cwd = deps.cwd || process.cwd();
+  const consoleErr = { error: (msg) => stderr.write(`${msg}\n`) };
+  const handlerDeps = { ...deps, stdout, stderr, env, cwd };
+  const run = (handler) => async (argv) => {
+    exitCode = await handler(argv, { ...handlerDeps, configFile: argv.configFile });
+  };
+
+  let exitCode = EXIT.OK;
+  try {
+    await yargs(argvInput)
+      .scriptName("conductor auth")
+      .strict()
+      .help()
+      .option("json", { type: "boolean", default: false })
+      .option("dry-run", { type: "boolean", default: false })
+      .option("config-file", { type: "string", describe: "Path to Conductor config file" })
+      .command("whoami", "Show the user the configured token belongs to", () => {}, run(handleWhoami))
+      .command("tokens", "List, create, or revoke API tokens", (tokens) => tokens
+        .command("list", "List active API tokens", () => {}, run(handleTokensList))
+        .command(
+          "create",
+          "Create an API token (the token is printed once)",
+          (cmd) => cmd.option("name", { type: "string", describe: `Token label (default "${DEFAULT_TOKEN_NAME}")` }),
+          run(handleTokensCreate),
+        )
+        .command(
+          "revoke <tokenId>",
+          "Revoke an API token",
+          (cmd) => cmd.positional("tokenId", { type: "string", demandOption: true }),
+          run(handleTokensRevoke),
+        )
+        .demandCommand(1))
+      .demandCommand(1)
+      .fail((msg, err) => {
+        if (err) {
+          throw err;
+        }
+        stderr.write(`${msg}\n`);
+        exitCode = EXIT.ARGS;
+      })
+      .parseAsync();
+  } catch (err) {
+    exitCode = reportError(consoleErr, err);
+  }
+  return exitCode;
+}
+
+if (isMainModule) {
+  main().then((code) => {
+    if (code !== 0) process.exit(code);
+  }).catch((err) => {
+    process.stderr.write(`${err instanceof Error ? err.message : String(err)}\n`);
+    process.exit(exitCodeForError(err));
+  });
+}

package/bin/conductor-daemon-query.js

@@ -1,5 +1,7 @@
 /**
- * conductor daemon list|tools|quota — read-only queries about daemons.
+ * conductor daemon list|tools|quota — read-only queries about daemons, plus the
+ * remote-control / sharing verbs in src/daemon-share-commands.js (restart,
+ * upgrade, sessions, accounts, switch-account, commands, share).
  *
  *   list [--all]                          Online daemons, CLI version, AI backends
  *   tools <host>                          AI tools installed on a daemon + network
@@ -12,24 +14,16 @@ import process from "node:process";
 
 import yargs from "yargs/yargs";
 
-import { EXIT, buildApis, pad, printJson, printPretty, reportError } from "../src/entity-helpers.js";
+import { EXIT, buildApis, printJson, printPretty, reportError } from "../src/entity-helpers.js";
+import { DAEMON_REMOTE_VERBS, printTable, readOnly, registerDaemonRemoteCommands } from "../src/daemon-share-commands.js";
 
-export const DAEMON_QUERY_VERBS = new Set(["list", "tools", "quota"]);
+export const DAEMON_QUERY_VERBS = new Set(["list", "tools", "quota", ...DAEMON_REMOTE_VERBS]);
 
 // 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);
@@ -139,12 +133,13 @@ export async function main(argvInput, deps = {}) {
   };
 
   try {
-    await yargs(argvInput)
+    const y = yargs(argvInput)
       .scriptName("conductor daemon")
       .strict()
       .help()
       .option("json", { type: "boolean", default: false })
       .option("config-file", { type: "string", describe: "Path to Conductor config file" })
+      .option("dry-run", { type: "boolean", default: false, describe: "Print the request a write verb would send, without sending it" })
       .command(
         "list",
         "List online daemons with their CLI version and AI backends",
@@ -153,13 +148,13 @@ export async function main(argvInput, deps = {}) {
           default: false,
           describe: `Include ephemeral ${FIRE_HOST_PREFIX}* hosts`,
         }),
-        run(handleList),
+        run(readOnly(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),
+        run(readOnly(handleTools)),
       )
       .command(
         "quota <host>",
@@ -168,8 +163,9 @@ export async function main(argvInput, deps = {}) {
           .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),
-      )
+        run(readOnly(handleQuota)),
+      );
+    await registerDaemonRemoteCommands(y, run)
       .demandCommand(1)
       .fail((msg, err) => {
         // Throw so the command handler does not run after a validation error

package/bin/conductor-daemon.js

@@ -24,7 +24,8 @@ import { DAEMON_QUERY_VERBS, main as runDaemonQuery } from "./conductor-daemon-q
 
 const argv = hideBin(process.argv);
 
-// `conductor daemon list|tools|quota` are read-only queries, not a daemon launch.
+// `conductor daemon list|tools|quota|restart|upgrade|sessions|accounts|switch-account|commands|share`
+// talk to the backend about daemons; they are 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])) {
@@ -181,6 +182,10 @@ const args = yargs(argv)
   .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")
+  .example("$0 restart <host> | upgrade <host> [--wait]", "Restart or upgrade a remote daemon")
+  .example("$0 sessions <host> | accounts <host> | switch-account <host> <name>", "Resumable AI sessions, codex accounts")
+  .example("$0 commands list|run|status <host> ...", "Run a daemon's custom commands")
+  .example("$0 share create|list|revoke|show-invite|accept ...", "Share a daemon with another user")
   .help()
   .strict()
   .parse();

package/bin/conductor-issue.js

@@ -5,13 +5,17 @@
  *
  * Subcommands:
  *   list [--project ...] [--status <s>] [--limit N]
+ *        [--all-projects | --project-ids a,b]   (cross-project listing)
  *   show <id>
  *   create --title <t> [--description <d> | --description-file FILE | --description-stdin]
- *          [--priority P1|P2|P3] [--status backlog|doing|done]
+ *          [--priority P0|P1|P2] [--status todo|done]
  *          [--client-request-id <key>] [--project ...]
  *   update <id> [--title ...] [--description ...] [--priority ...] [--status ...]
- *   start <id>          (alias for update --status doing)
+ *   start <id> [--backend <b>] [--global-backend <backend>@<host>]
+ *              [--daemon <host>] [--project <id>]
+ *                       (alias for update --status doing)
  *   done <id> [--evidence <text>|@FILE]
+ *   delete <id> --yes    (the server refuses issues still in doing)
  *
  * Global flags supported on every write subcommand:
  *   --json, --dry-run, --project, --config-file
@@ -39,6 +43,7 @@ import {
   reportError,
   resolveProject,
 } from "../src/entity-helpers.js";
+import { apiPath, argsError, buildHttp, sendOrPreview, formatTable, projectLabels } from "../src/backend-http.js";
 
 const isMainModule = (() => {
   const currentFile = fileURLToPath(import.meta.url);
@@ -67,6 +72,21 @@ function issueAsObject(issue) {
   };
 }
 
+// `codex@ubuntu` → { backend: "codex", host: "ubuntu" } (RFC 0041 global AI backend).
+function parseGlobalBackend(value) {
+  if (value === undefined) return undefined;
+  const raw = String(value).trim();
+  const at = raw.indexOf("@");
+  const backend = at > 0 ? raw.slice(0, at).trim().toLowerCase() : "";
+  const host = at > 0 ? raw.slice(at + 1).trim() : "";
+  if (!backend || !host) {
+    const err = new Error(`--global-backend must look like <backend>@<host>, got "${raw}"`);
+    err.code = "ARGS";
+    throw err;
+  }
+  return { host, backend };
+}
+
 function parseStatusList(value) {
   if (!value) return undefined;
   return String(value)
@@ -75,13 +95,107 @@ function parseStatusList(value) {
     .filter(Boolean);
 }
 
+// Legacy statuses the server serves as their canonical value
+// (web/src/lib/issues/config.ts LEGACY_ISSUE_STATUS_ALIASES).
+const LEGACY_ISSUE_STATUS_ALIASES = { backlog: "todo", review: "doing" };
+function canonicalIssueStatus(value) {
+  const normalized = String(value ?? "").trim().toLowerCase();
+  return LEGACY_ISSUE_STATUS_ALIASES[normalized] ?? normalized;
+}
+
+function parseIdList(value) {
+  if (value === undefined || value === null) return [];
+  const values = Array.isArray(value) ? value : [value];
+  return [...new Set(values
+    .flatMap((entry) => String(entry).split(","))
+    .map((entry) => entry.trim())
+    .filter(Boolean))];
+}
+
+/**
+ * Cross-project listing straight off GET /api/issues: no `project_id` lists
+ * every project the user can access (own + collaborations); `project_ids`
+ * lists exactly those projects (what the merged cross-daemon view uses). The
+ * server filters `status` (older servers ignore it, so it is re-applied here);
+ * the route has no limit param, so that is applied here.
+ */
+async function handleListAcross(argv, deps) {
+  const projectIds = parseIdList(argv.projectIds);
+  if (argv.allProjects && projectIds.length > 0) {
+    throw argsError("Pass either --all-projects or --project-ids, not both");
+  }
+  if (argv.project && (argv.allProjects || projectIds.length > 0)) {
+    throw argsError("--project cannot be combined with --all-projects/--project-ids");
+  }
+  const http = await buildHttp(deps);
+  const statuses = parseStatusList(argv.status);
+  const query = {
+    ...(projectIds.length > 0 ? { project_ids: projectIds.join(",") } : {}),
+    ...(statuses && statuses.length > 0 ? { status: statuses.join(",") } : {}),
+  };
+  const raw = await http.get("/api/issues", {
+    query: Object.keys(query).length > 0 ? query : undefined,
+  });
+  let issues = Array.isArray(raw) ? raw : [];
+  if (statuses && statuses.length > 0) {
+    const wanted = new Set(statuses.map(canonicalIssueStatus));
+    issues = issues.filter((issue) => wanted.has(canonicalIssueStatus(issue.status)));
+  }
+  if (argv.limit !== undefined) issues = issues.slice(0, argv.limit);
+  if (argv.json) {
+    // Same shape as the single-project `list --json` (the SDK-normalized form).
+    printJson(deps.stdout, issues.map((issue) => issueAsObject({
+      ...issue,
+      projectId: issue.projectId ?? issue.project_id,
+      createdAt: issue.createdAt ?? issue.created_at,
+      updatedAt: issue.updatedAt ?? issue.updated_at,
+    })));
+    return EXIT.OK;
+  }
+  if (issues.length === 0) {
+    printPretty(deps.stdout, "(no issues)");
+    return EXIT.OK;
+  }
+  const names = await projectLabels(http);
+  const rows = issues.map((issue) => {
+    const projectId = issue.projectId ?? issue.project_id ?? "";
+    const projectLabel = issue.projectName ?? issue.project_name ?? names.get(projectId) ?? projectId;
+    return [issue.id, projectLabel, issue.status ?? "", issue.priority ?? "", issue.title ?? ""];
+  });
+  for (const line of formatTable(["ID", "PROJECT", "STATUS", "PRIO", "TITLE"], rows)) {
+    printPretty(deps.stdout, line);
+  }
+  return EXIT.OK;
+}
+
+async function handleDelete(argv, deps) {
+  if (!argv.yes && !argv.dryRun) {
+    throw argsError("Refusing to delete without --yes");
+  }
+  const http = await buildHttp(deps);
+  const result = await sendOrPreview(http, argv, deps, "DELETE", apiPath("issues", argv.id), undefined);
+  if (result.dryRun) return EXIT.OK;
+  if (argv.json) {
+    printJson(deps.stdout, { deleted: true, id: argv.id });
+    return EXIT.OK;
+  }
+  printPretty(deps.stdout, `Deleted issue ${argv.id}`);
+  return EXIT.OK;
+}
+
 async function handleList(argv, deps) {
+  if (argv.limit !== undefined && !(Number.isInteger(argv.limit) && argv.limit > 0)) {
+    throw argsError("--limit must be a positive integer");
+  }
+  if (argv.allProjects || parseIdList(argv.projectIds).length > 0) {
+    return handleListAcross(argv, deps);
+  }
   const apis = await buildApis(deps);
   const project = await resolveProject(apis, { env: deps.env, cwd: deps.cwd, project: argv.project });
   const list = await apis.issues.listIssues({
     projectId: project.id,
     status: parseStatusList(argv.status),
-    limit: argv.limit ? Number(argv.limit) : undefined,
+    limit: argv.limit,
   });
   const objects = (Array.isArray(list) ? list : []).map(issueAsObject);
   if (argv.json) {
@@ -163,6 +277,42 @@ async function handleCreate(argv, deps) {
   return EXIT.OK;
 }
 
+/**
+ * Target project for `issue start`: `--project` as given, else — for
+ * `--daemon` on a project bound to another daemon — the same-named sibling
+ * project on that daemon. The server re-checks that it is a merged sibling.
+ */
+async function resolveStartProjectId(apis, argv, daemonHost) {
+  if (argv.project) {
+    return (await resolveProject(apis, { project: argv.project })).id;
+  }
+  if (!daemonHost) return undefined;
+  const issue = await apis.issues.getIssue(argv.id);
+  let current;
+  try {
+    current = await apis.projects.getProject(issue.projectId);
+  } catch (err) {
+    // Another member's shared project is not readable here: skip the sibling
+    // pick and let the server explain what it allows.
+    const status = err?.statusCode ?? err?.status;
+    const notFound = err?.name === "ProjectNotResolvedError" && err.reason === "not_found";
+    if (notFound || status === 404 || status === 403) return undefined;
+    throw err;
+  }
+  if (!current.daemonHost || current.daemonHost === daemonHost) return undefined;
+  const siblings = (await apis.projects.listProjects()).filter(
+    (project) => project.name === current.name && project.daemonHost === daemonHost,
+  );
+  if (siblings.length !== 1) {
+    throw argsError(
+      siblings.length === 0
+        ? `No project "${current.name}" on daemon ${daemonHost}; pass --project <id>`
+        : `Several projects "${current.name}" on daemon ${daemonHost}; pass --project <id>`,
+    );
+  }
+  return siblings[0].id;
+}
+
 async function handleUpdate(argv, deps, overrides = {}) {
   const apis = await buildApis(deps);
   const description = readDescription({
@@ -177,12 +327,26 @@ async function handleUpdate(argv, deps, overrides = {}) {
   // scope here (review M5 — current behavior accepted as documented).
   const status = overrides.status || argv.status;
   const evidence = overrides.evidence;
-  const metadata = buildAuditMetadata(deps.env);
+  const globalBackend = parseGlobalBackend(argv.globalBackend);
+  // The server reads the spawned task's backend from `metadata.backendType`.
+  const backendType = globalBackend?.backend ?? (argv.backend ? String(argv.backend) : undefined);
+  const daemonHost = argv.daemon ? String(argv.daemon).trim() : undefined;
+  const metadata = buildAuditMetadata(deps.env, {
+    ...(backendType ? { backendType } : {}),
+    ...(daemonHost ? { daemonHost } : {}),
+  });
+  // `start` only: the web's doing dialog re-parents the issue onto the chosen
+  // daemon's sibling project in a merged cross-daemon group.
+  const targetProjectId = overrides.status === "doing"
+    ? await resolveStartProjectId(apis, argv, daemonHost)
+    : undefined;
   const body = {
+    ...(targetProjectId ? { projectId: targetProjectId } : {}),
     ...(argv.title ? { title: String(argv.title) } : {}),
     ...(description !== undefined ? { description } : {}),
     ...(argv.priority ? { priority: String(argv.priority) } : {}),
     ...(status ? { status: String(status) } : {}),
+    ...(globalBackend ? { globalBackend } : {}),
     metadata,
   };
   if (Object.keys(body).filter((key) => key !== "metadata").length === 0) {
@@ -235,6 +399,19 @@ async function handleUpdate(argv, deps, overrides = {}) {
   } else {
     updated = await apis.issues.updateIssue(argv.id, body);
   }
+  if (globalBackend) {
+    // A server that predates issue global backends drops the field and still
+    // starts a plain task on the project's own daemon.
+    const task = updated?.raw?.activeTask;
+    const ranOn = task?.agentHost ?? task?.agent_host ?? null;
+    if (ranOn !== globalBackend.host) {
+      deps.stderr.write(
+        `warning: the task did not start on ${globalBackend.backend}@${globalBackend.host}`
+          + ` (${ranOn ? `it runs on ${ranOn}` : "no task was started"});`
+          + " the Conductor server may be too old for --global-backend\n",
+      );
+    }
+  }
   const obj = issueAsObject(updated);
   if (argv.json) {
     printJson(deps.stdout, obj);
@@ -266,8 +443,10 @@ export async function main(argvInput = hideBin(process.argv), deps = {}) {
         "list",
         "List issues",
         (cmd) => cmd
-          .option("status", { type: "string", describe: "Comma-separated status filter (e.g. backlog,doing)" })
-          .option("limit", { type: "number" }),
+          .option("status", { type: "string", describe: "Comma-separated status filter: todo,doing,done" })
+          .option("limit", { type: "number" })
+          .option("all-projects", { type: "boolean", default: false, describe: "List issues across every accessible project" })
+          .option("project-ids", { type: "string", describe: "Comma-separated project ids to list issues across" }),
         async (argv) => {
           exitCode = await handleList(argv, { ...handlerDeps, configFile: argv.configFile });
         },
@@ -288,8 +467,9 @@ export async function main(argvInput = hideBin(process.argv), deps = {}) {
           .option("description", { type: "string" })
           .option("description-file", { type: "string" })
           .option("description-stdin", { type: "boolean", default: false })
-          .option("priority", { choices: ["P1", "P2", "P3"] })
-          .option("status", { choices: ["backlog", "doing", "done"] })
+          .option("priority", { choices: ["P0", "P1", "P2"] })
+          // Only moving into doing starts an issue's task: create, then `start`.
+          .option("status", { choices: ["todo", "done"] })
           .option("client-request-id", { type: "string" }),
         async (argv) => {
           exitCode = await handleCreate(argv, { ...handlerDeps, configFile: argv.configFile });
@@ -304,8 +484,8 @@ export async function main(argvInput = hideBin(process.argv), deps = {}) {
           .option("description", { type: "string" })
           .option("description-file", { type: "string" })
           .option("description-stdin", { type: "boolean", default: false })
-          .option("priority", { choices: ["P1", "P2", "P3"] })
-          .option("status", { choices: ["backlog", "doing", "done"] }),
+          .option("priority", { choices: ["P0", "P1", "P2"] })
+          .option("status", { choices: ["todo", "doing", "done"] }),
         async (argv) => {
           exitCode = await handleUpdate(argv, { ...handlerDeps, configFile: argv.configFile });
         },
@@ -313,7 +493,18 @@ export async function main(argvInput = hideBin(process.argv), deps = {}) {
       .command(
         "start <id>",
         "Mark issue as doing (alias for update --status doing)",
-        (cmd) => cmd.positional("id", { type: "string", demandOption: true }),
+        (cmd) => cmd
+          .positional("id", { type: "string", demandOption: true })
+          .option("backend", { type: "string", describe: "AI backend for the spawned task, e.g. codex or claude" })
+          .option("global-backend", {
+            type: "string",
+            describe: "Run the AI on a global AI backend from settings, as <backend>@<host>",
+          })
+          .option("daemon", {
+            type: "string",
+            describe: "Daemon to run the task on (merged cross-daemon groups and the default project)",
+          })
+          .conflicts("backend", "global-backend"),
         async (argv) => {
           exitCode = await handleUpdate(argv, { ...handlerDeps, configFile: argv.configFile }, { status: "doing" });
         },
@@ -332,13 +523,24 @@ export async function main(argvInput = hideBin(process.argv), deps = {}) {
           });
         },
       )
+      .command(
+        "delete <id>",
+        "Delete an issue (requires --yes)",
+        (cmd) => cmd
+          .positional("id", { type: "string", demandOption: true })
+          .option("yes", { type: "boolean", default: false, describe: "Confirm the deletion" }),
+        async (argv) => {
+          exitCode = await handleDelete(argv, { ...handlerDeps, configFile: argv.configFile });
+        },
+      )
       .demandCommand(1)
       .fail((msg, err) => {
         if (err) {
           throw err;
         }
-        stderr.write(`${msg}\n`);
-        exitCode = EXIT.ARGS;
+        // Throw so yargs stops here; returning would still run the command
+        // (e.g. `create --priority P3` was sent to the server anyway).
+        throw argsError(msg);
       })
       .parseAsync();
   } catch (err) {