@sideboard-ai/cli 0.1.9

package/LICENSE

@@ -0,0 +1,190 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   Copyright 2026 Sideboard contributors
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/README.md

@@ -0,0 +1,13 @@
+# `@sideboard-ai/cli`
+
+Agent-agnostic worktree orchestration from the terminal.
+
+```bash
+npm i -g @sideboard-ai/cli
+
+sideboard ls
+sideboard send <thread> "…"
+sideboard mcp          # MCP stdio server
+```
+
+Also installs `side` as a short alias. The MCP server is available as `sideboard mcp`, or via `@sideboard-ai/core`'s `sideboard-mcp` bin.

package/dist/index.js

@@ -0,0 +1,636 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { createInterface } from "readline";
+import { spawn } from "child_process";
+import chalk from "chalk";
+import { Command } from "commander";
+import {
+  detectAgents,
+  getOrchestrator,
+  listBranches,
+  listPrs,
+  listIssues,
+  listLinearIssues,
+  resolveRepoRoot,
+  startMcpServer,
+  startOrchestration,
+  hasRepoHook,
+  settingsSourceLabel,
+  runCloudConnect,
+  getBrightsySession,
+  switchBrightsyAccount,
+  connectBrightsyTeam,
+  disconnectBrightsyTeam
+} from "@sideboard-ai/core";
+var VERSION = "0.1.0";
+async function printUpgradeHint() {
+  try {
+    const { execFile } = await import("child_process");
+    const latest = await new Promise((resolve, reject) => {
+      execFile(
+        "npm",
+        ["view", "@sideboard-ai/cli", "version"],
+        { timeout: 2500 },
+        (err, stdout) => {
+          if (err) reject(err);
+          else resolve(String(stdout).trim());
+        }
+      );
+    });
+    if (latest && latest !== VERSION) {
+      console.error(
+        chalk.dim(
+          `Upgrade available: ${latest} (you have ${VERSION}). npm i -g @sideboard-ai/cli`
+        )
+      );
+    }
+  } catch {
+  }
+}
+async function confirm(question) {
+  if (!process.stdin.isTTY) {
+    throw new Error("Interactive confirmation required (no TTY) \u2014 land has no --yes in v1");
+  }
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  return new Promise((resolve) => {
+    rl.question(`${question} [y/N] `, (answer) => {
+      rl.close();
+      resolve(/^y(es)?$/i.test(answer.trim()));
+    });
+  });
+}
+function parseAgent(raw) {
+  if (raw === "claude" || raw === "codex" || raw === "opencode" || raw === "brightsy" || raw === "cursor") {
+    return raw;
+  }
+  throw new Error(`Unknown agent: ${raw}`);
+}
+function parseFrom(raw) {
+  const idx = raw.indexOf(":");
+  if (idx === -1) throw new Error(`--from must be branch:<name>|pr:<n>|ticket:<key>, got ${raw}`);
+  const kind = raw.slice(0, idx);
+  const ref = raw.slice(idx + 1);
+  if (kind !== "branch" && kind !== "pr" && kind !== "ticket") {
+    throw new Error(`Unknown source kind: ${kind}`);
+  }
+  if (!ref) throw new Error(`Missing source ref in ${raw}`);
+  return { sourceType: kind, sourceRef: ref };
+}
+async function main() {
+  if (process.argv.includes("-V") || process.argv.includes("--version")) {
+    console.log(VERSION);
+    await printUpgradeHint();
+    return;
+  }
+  const program = new Command();
+  program.name("sideboard").description("Your agent threads aren't trapped anywhere.").version(VERSION);
+  const orch = getOrchestrator();
+  program.command("detect").description("Show agent availability, auth, MCP, and warnings").action(async () => {
+    const statuses = await detectAgents();
+    for (const s of statuses) {
+      const ok = s.installed && s.authenticated;
+      const mark = ok ? chalk.green("\u2713") : chalk.red("\u2717");
+      console.log(
+        `${mark} ${chalk.bold(s.agent)}  installed=${s.installed}  auth=${s.authenticated}  linearMcp=${s.linearMcp}`
+      );
+      if (s.reason) console.log(chalk.yellow(`  ${s.reason}`));
+      for (const w of s.warnings) console.log(chalk.yellow(`  warning: ${w}`));
+    }
+  });
+  program.command("new").description("Create a thread from branch, PR, or Linear ticket").requiredOption("--from <spec>", "branch:<name>|pr:<n>|ticket:<key>").requiredOption("--agent <agent>", "claude|codex|opencode|brightsy|cursor").option("--repo <path>", "repo path", process.cwd()).option("--title <title>", "thread title").action(async (opts) => {
+    await orch.reconcile(opts.repo);
+    const { sourceType, sourceRef } = parseFrom(opts.from);
+    const agent = parseAgent(opts.agent);
+    const repoPath = await resolveRepoRoot(opts.repo);
+    console.log(chalk.dim(`Creating ${sourceType} thread in ${repoPath}\u2026`));
+    const hook = settingsSourceLabel(repoPath);
+    if (hook) {
+      console.log(chalk.dim(`Found ${hook} \u2014 will run setup / enable dev`));
+    } else if (hasRepoHook(repoPath)) {
+      console.log(chalk.dim("Repo hook present"));
+    }
+    const thread = await orch.createThread({
+      sourceType,
+      sourceRef,
+      agent,
+      repoPath,
+      title: opts.title
+    });
+    console.log(chalk.green(`Created ${thread.id.slice(0, 8)}  ${thread.branchName}`));
+    console.log(`  worktree: ${thread.worktreePath}`);
+    console.log(`  agent:    ${thread.agent}`);
+  });
+  program.command("adopt").description("Adopt an existing worktree or import from Conductor").argument("[path]", "worktree path").option("--agent <agent>", "claude|codex|opencode|brightsy|cursor", "claude").option("--from-conductor", "import from Conductor DB").option("--all", "import all Conductor workspaces").option("--id <id>", "Conductor workspace id").action(async (path, opts) => {
+    if (opts.fromConductor) {
+      const workspaces = orch.listConductor();
+      if (opts.all) {
+        for (const w of workspaces) {
+          if (!w.workspacePath) continue;
+          try {
+            const t3 = await orch.adoptFromConductor(w.id);
+            console.log(chalk.green(`Imported ${t3.id.slice(0, 8)}  ${t3.title}  (${t3.messages.length} msgs)`));
+          } catch (err) {
+            console.error(chalk.red(`Skip ${w.workspaceName}: ${err instanceof Error ? err.message : err}`));
+          }
+        }
+        return;
+      }
+      if (opts.id) {
+        const t3 = await orch.adoptFromConductor(opts.id);
+        console.log(chalk.green(`Imported ${t3.id.slice(0, 8)}  ${t3.title}`));
+        return;
+      }
+      console.log(chalk.bold("Conductor workspaces:"));
+      workspaces.forEach((w, i) => {
+        console.log(
+          `  ${String(i + 1).padStart(2)}. ${w.workspaceName}  ${w.branch}  msgs=${w.messageCount}  ${w.id.slice(0, 8)}`
+        );
+      });
+      if (!process.stdin.isTTY) {
+        console.log(chalk.dim("Pass --id <id> or --all to import non-interactively"));
+        return;
+      }
+      const rl = createInterface({ input: process.stdin, output: process.stdout });
+      const answer = await new Promise((resolve) => {
+        rl.question("Import number (or q): ", resolve);
+      });
+      rl.close();
+      if (answer === "q") return;
+      const idx = Number(answer) - 1;
+      const chosen = workspaces[idx];
+      if (!chosen) throw new Error("Invalid selection");
+      const t2 = await orch.adoptFromConductor(chosen.id);
+      console.log(chalk.green(`Imported ${t2.id.slice(0, 8)}  ${t2.title}  (${t2.messages.length} msgs)`));
+      return;
+    }
+    if (!path) throw new Error("Provide a worktree path or --from-conductor");
+    const t = await orch.adopt({
+      worktreePath: path,
+      agent: parseAgent(opts.agent)
+    });
+    console.log(chalk.green(`Adopted ${t.id.slice(0, 8)}  ${t.branchName}`));
+  });
+  program.command("ls").description("List threads").option("--archived", "include archived").action(async (opts) => {
+    const threads = orch.getThreads(Boolean(opts.archived));
+    if (!threads.length) {
+      console.log("(no threads)");
+      return;
+    }
+    for (const t of threads) {
+      const port = t.devPort ? chalk.cyan(` http://localhost:${t.devPort}`) : "";
+      console.log(
+        `${t.id.slice(0, 8)}  ${statusColor(t.status)}  ${t.agent.padEnd(8)}  ${t.sourceType}:${t.sourceRef}  ${t.title}${port}`
+      );
+    }
+  });
+  program.command("watch").description("Live TTY dashboard of all threads").action(async () => {
+    await orch.reconcile();
+    const render = () => {
+      console.clear();
+      console.log(chalk.bold("sideboard watch") + chalk.dim(`  ${(/* @__PURE__ */ new Date()).toLocaleTimeString()}`));
+      console.log(chalk.dim("\u2500".repeat(72)));
+      for (const t of orch.getThreads()) {
+        const q = t.queue.length ? chalk.yellow(` q=${t.queue.length}`) : "";
+        const port = t.devPort ? chalk.cyan(` :${t.devPort}`) : "";
+        console.log(
+          `${t.id.slice(0, 8)}  ${statusColor(t.status)}${q}${port}  ${t.agent}  ${t.title}`
+        );
+      }
+    };
+    render();
+    orch.on(() => render());
+    await new Promise(() => {
+    });
+  });
+  program.command("send").description("Send a prompt to a thread (queues if running)").argument("[thread]", "thread id/ref").argument("[prompt]", "prompt text").option("--to <refs>", "comma-separated thread refs for fan-out").action(async (thread, prompt, opts) => {
+    await orch.reconcile();
+    if (opts.to) {
+      if (!prompt && thread) prompt = thread;
+      if (!prompt) throw new Error("Prompt required");
+      const refs = String(opts.to).split(",").map((s) => s.trim());
+      const off2 = orch.on((event) => {
+        if (event.type === "turn_output" && event.event.type === "stdout") {
+          process.stdout.write(event.event.data);
+        }
+        if (event.type === "turn_output" && event.event.type === "stderr") {
+          process.stderr.write(event.event.data + "\n");
+        }
+      });
+      await orch.fanOut(refs, prompt);
+      for (const ref of refs) {
+        await orch.waitForTurn(ref);
+      }
+      off2();
+      return;
+    }
+    if (!thread || !prompt) throw new Error('Usage: sideboard send <thread> "<prompt>"');
+    const off = orch.on((event) => {
+      if (event.type === "turn_output" && event.threadId.startsWith(thread.slice(0, 8))) {
+        if (event.event.type === "stdout") process.stdout.write(event.event.data);
+        if (event.event.type === "stderr") process.stderr.write(event.event.data + "\n");
+      }
+    });
+    await orch.send(thread, prompt);
+    const done = await orch.waitForTurn(thread);
+    off();
+    console.log(chalk.dim(`
+[${done.status}]`));
+  });
+  program.command("stop").argument("<thread>", "thread id/ref").action(async (thread) => {
+    const t = orch.stop(thread);
+    console.log(chalk.yellow(`Stopped ${t.id.slice(0, 8)}`));
+  });
+  program.command("attach").description("Exec the native CLI interactively in the thread worktree").argument("<thread>", "thread id/ref").action(async (thread) => {
+    const cmd = await orch.attachCommand(thread);
+    console.log(chalk.dim(`Attaching: ${cmd.file} ${cmd.args.join(" ")}`));
+    const child = spawn(cmd.file, cmd.args, {
+      cwd: cmd.cwd,
+      env: { ...process.env, ...cmd.env },
+      stdio: "inherit"
+    });
+    await new Promise((resolve, reject) => {
+      child.on("exit", () => resolve());
+      child.on("error", reject);
+    });
+  });
+  program.command("dev").description("Start/stop per-worktree run script").argument("<thread>", "thread id/ref").argument("[script]", "named run script (default script if omitted)").option("--stop", "stop the run script").action(async (thread, script, opts) => {
+    if (opts.stop) {
+      orch.stopDev(thread, script);
+      console.log(chalk.yellow(script ? `Stopped ${script}` : "Run scripts stopped"));
+      return;
+    }
+    const { port, scriptName } = await orch.startDev(thread, script);
+    console.log(chalk.green(`${scriptName} on http://localhost:${port}`));
+  });
+  program.command("setup").description("Re-run workspace setup for a thread").argument("<thread>", "thread id/ref").action(async (thread) => {
+    const off = orch.on((event) => {
+      if (event.type === "setup_output" && event.threadId.startsWith(thread.slice(0, 8))) {
+        console.log(event.line);
+      }
+    });
+    const result = await orch.runSetup(thread);
+    off();
+    console.log(
+      chalk.green(`Setup finished exit=${result.exitCode}${result.source ? ` (${result.source})` : ""}`)
+    );
+  });
+  const workspaceCmd = program.command("workspace").description("Manage registered Sideboard workspaces (repos)");
+  workspaceCmd.command("ls").description("List workspaces").action(() => {
+    const list = orch.listWorkspaces();
+    if (!list.length) {
+      console.log("(no workspaces)");
+      return;
+    }
+    for (const w of list) {
+      console.log(`${w.name}  ${w.path}`);
+    }
+  });
+  workspaceCmd.command("add").argument("<path>", "git repo path").action(async (path) => {
+    const repoPath = await resolveRepoRoot(path);
+    const w = await orch.addWorkspace(repoPath);
+    console.log(chalk.green(`Added ${w.name}  ${w.path}`));
+  });
+  workspaceCmd.command("rm").argument("<path>", "git repo path").action(async (path) => {
+    const repoPath = await resolveRepoRoot(path);
+    orch.removeWorkspace(repoPath);
+    console.log(chalk.yellow(`Removed ${repoPath}`));
+  });
+  program.command("clone").description("Clone a repo into ~/sideboard/repos and register it").argument("<url>", "git clone URL").option("--name <name>", "directory name under ~/sideboard/repos").action(async (url, opts) => {
+    const { repoPath, workspace } = await orch.cloneRepo(url, opts.name);
+    console.log(chalk.green(`Cloned ${workspace.name}`));
+    console.log(`  path: ${repoPath}`);
+  });
+  program.command("apply").description("Merge/cherry-pick thread branch into the main checkout (no PR)").argument("<thread>", "thread id/ref").option("--method <method>", "merge|cherry-pick", "merge").option("--target <branch>", "target branch (default: repo default)").action(async (thread, opts) => {
+    const method = opts.method === "cherry-pick" ? "cherry-pick" : "merge";
+    const ok = await confirm(
+      `Apply thread into main checkout via ${method}? This modifies the main working tree.`
+    );
+    if (!ok) {
+      console.log("Aborted");
+      return;
+    }
+    const result = await orch.applyIntoMain(thread, {
+      method,
+      targetBranch: opts.target
+    });
+    console.log(chalk.green(result.message));
+  });
+  program.command("orphans").description("List or clean orphan Sideboard worktrees").option("--clean", "remove orphans beyond worktreeMaxCount").option("--dry-run", "show what would be removed").option("--repo <path>", "limit to one repo").action(async (opts) => {
+    if (opts.clean) {
+      const result = await orch.cleanupOrphans({
+        dryRun: Boolean(opts.dryRun),
+        repoPath: opts.repo
+      });
+      console.log(
+        chalk.bold(
+          opts.dryRun ? `Would remove ${result.removed.length}, keep ${result.kept.length}` : `Removed ${result.removed.length}, kept ${result.kept.length}`
+        )
+      );
+      for (const p of result.removed) console.log(chalk.red(`  - ${p}`));
+      for (const p of result.kept) console.log(chalk.dim(`  keep ${p}`));
+      return;
+    }
+    const orphans = await orch.listOrphanWorktrees(opts.repo);
+    if (!orphans.length) {
+      console.log("(no orphans)");
+      return;
+    }
+    for (const o of orphans) {
+      console.log(`${o.path}  (${o.repoPath})`);
+    }
+  });
+  program.command("best-of-n").description("Create one thread per agent with the same prompt (Cursor-style fanout)").argument("<prompt>", "prompt text").requiredOption(
+    "--agents <list>",
+    "comma-separated agents (claude,codex,opencode,cursor,brightsy)"
+  ).option("--repo <path>", "repo path", process.cwd()).option("--from <spec>", "branch:<name>|pr:<n>|ticket:<key>", "branch:default").action(async (prompt, opts) => {
+    const agents = String(opts.agents).split(",").map((s) => parseAgent(s.trim()));
+    const repoPath = await resolveRepoRoot(opts.repo);
+    const { sourceType, sourceRef } = parseFrom(opts.from);
+    const threads = await orch.bestOfN({
+      prompt,
+      agents,
+      repoPath,
+      sourceType,
+      sourceRef
+    });
+    for (const t of threads) {
+      console.log(
+        chalk.green(`${t.id.slice(0, 8)}  ${t.agent.padEnd(8)}  ${t.branchName}`)
+      );
+    }
+  });
+  program.command("diff").argument("<thread>", "thread id/ref").action(async (thread) => {
+    const diff = await orch.diff(thread);
+    console.log(chalk.bold(`base: ${diff.base}`) + (diff.dirty ? chalk.yellow(" (dirty)") : ""));
+    console.log(diff.stat);
+    console.log("");
+    for (const f of diff.files) {
+      console.log(chalk.cyan(`--- ${f.path} (${f.status})`));
+      console.log(f.patch);
+    }
+  });
+  program.command("open").argument("<thread>", "thread id/ref").option("--editor <cmd>", "editor command", process.env.SIDEBOARD_EDITOR ?? "cursor").action(async (thread, opts) => {
+    const t = orch.getThread(thread);
+    if (!t) throw new Error(`Thread not found: ${thread}`);
+    spawn(opts.editor, [t.worktreePath], { stdio: "inherit", detached: true }).unref();
+    console.log(chalk.green(`Opened ${t.worktreePath} in ${opts.editor}`));
+  });
+  program.command("land").argument("<thread>", "thread id/ref").option("--draft", "create/update as a draft PR").action(async (thread, opts) => {
+    const preview = await orch.previewLand(thread);
+    console.log(chalk.bold("Land preview"));
+    console.log(`  branch: ${preview.branch}`);
+    console.log(`  target: ${preview.target}`);
+    console.log(`  dirty:  ${preview.dirty}${preview.dirty ? " (will auto-commit on confirm)" : ""}`);
+    console.log(`  draft:  ${Boolean(opts.draft)}`);
+    console.log(`  stat:
+${preview.diffStat}`);
+    if (preview.blocked) {
+      console.error(chalk.red(preview.blockReason));
+      process.exitCode = 1;
+      return;
+    }
+    const ok = await confirm(
+      opts.draft ? "Push and create/update DRAFT PR?" : "Push and create/update PR?"
+    );
+    if (!ok) {
+      console.log("Aborted");
+      return;
+    }
+    const result = await orch.confirmLand(thread, { draft: Boolean(opts.draft) });
+    console.log(chalk.green(`PR: ${result.prUrl}`));
+  });
+  program.command("rm").argument("<thread>", "thread id/ref").option("--purge", "delete record too").option("--delete-branch", "also delete the git branch (with --purge)").action(async (thread, opts) => {
+    if (opts.purge) {
+      const ok = await confirm(`Purge thread ${thread}? This deletes the record.`);
+      if (!ok) return;
+      await orch.purge(thread, { deleteBranch: Boolean(opts.deleteBranch) });
+      console.log(chalk.red("Purged"));
+      return;
+    }
+    const t = await orch.archive(thread);
+    console.log(chalk.yellow(`Archived ${t.id.slice(0, 8)}`));
+  });
+  program.command("restore").argument("<thread>", "thread id/ref").action(async (thread) => {
+    const t = await orch.restore(thread);
+    console.log(chalk.green(`Restored ${t.id.slice(0, 8)}`));
+  });
+  program.command("orchestrate").argument("<goal>", "orchestration goal").option("--agent <agent>", "claude|codex|opencode|cursor", "claude").option(
+    "--repo <path>",
+    "optional legacy pinned-repo home (omit for Global workspace)"
+  ).action(async (goal, opts) => {
+    const agent = parseAgent(opts.agent);
+    if (agent === "brightsy") {
+      throw new Error(
+        "orchestrate is not supported with brightsy \u2014 use claude, codex, opencode, or cursor"
+      );
+    }
+    const repoPath = opts.repo ? await resolveRepoRoot(opts.repo) : void 0;
+    const thread = await startOrchestration({ goal, agent, repoPath });
+    const agentCwd = thread.worktreePath || process.cwd();
+    console.log(chalk.bold("Orchestration thread"), thread.id.slice(0, 8));
+    console.log(chalk.dim("Registering sideboard MCP with agent and starting coordinator\u2026"));
+    console.log(
+      chalk.dim(
+        "Tip: MCP is for judgment. Use `sideboard ls/send/diff/land` for mechanical control (zero tokens)."
+      )
+    );
+    const systemHint = [
+      "You are a Sideboard coordinator.",
+      "You operate from the Global workspace (no git home). Use Sideboard MCP tools only.",
+      "Use Sideboard MCP tools for persistent cross-agent threads, land/dev lifecycle, and work that outlives this session.",
+      'For same-session Claude subtasks, prefer Claude Code native Agent(isolation: "worktree") instead.',
+      "You cannot confirm_land or purge_thread \u2014 those stay human-only.",
+      `Goal: ${goal}`,
+      repoPath ? `Pinned repo (legacy): ${repoPath}` : "Workspace: Global",
+      `Parent thread id (pass as parentThreadId when creating children): ${thread.id}`
+    ].join("\n");
+    const mcpConfig = {
+      mcpServers: {
+        sideboard: {
+          command: "sideboard",
+          args: ["mcp"]
+        }
+      }
+    };
+    const { writeFileSync, mkdtempSync } = await import("fs");
+    const { join } = await import("path");
+    const { tmpdir } = await import("os");
+    const dir = mkdtempSync(join(tmpdir(), "sideboard-orch-"));
+    const cfgPath = join(dir, "mcp.json");
+    writeFileSync(cfgPath, JSON.stringify(mcpConfig, null, 2));
+    let child;
+    if (agent === "claude") {
+      child = spawn(
+        "claude",
+        ["-p", systemHint, "--mcp-config", cfgPath, "--permission-mode", "plan"],
+        { cwd: agentCwd, stdio: "inherit" }
+      );
+    } else if (agent === "codex") {
+      child = spawn("codex", ["exec", systemHint, "--cd", agentCwd], {
+        cwd: agentCwd,
+        stdio: "inherit"
+      });
+    } else if (agent === "cursor") {
+      child = spawn(
+        "cursor-agent",
+        ["--workspace", agentCwd, systemHint],
+        { cwd: agentCwd, stdio: "inherit", env: process.env }
+      );
+      child.on("error", () => {
+        console.error(
+          chalk.yellow(
+            "cursor-agent CLI not found \u2014 orchestration thread was created; use MCP from Claude/Codex or the desktop app."
+          )
+        );
+      });
+    } else {
+      child = spawn("opencode", ["run", systemHint, "--dir", agentCwd], {
+        cwd: agentCwd,
+        stdio: "inherit"
+      });
+    }
+    await new Promise((resolve) => child.on("exit", () => resolve()));
+  });
+  program.command("mcp").description("Run the Sideboard MCP stdio server").action(async () => {
+    await startMcpServer();
+  });
+  const brightsyCmd = program.command("brightsy").description(
+    "Brightsy team helpers (wraps `brightsy teams` + Sideboard multi-team MCP state)"
+  );
+  brightsyCmd.command("teams").alias("accounts").description("List Brightsy teams (via `brightsy teams --json`)").action(async () => {
+    const session = await getBrightsySession();
+    if (!session.connected) {
+      console.error(chalk.red(session.reason || "Not logged in \u2014 brightsy login"));
+      process.exitCode = 1;
+      return;
+    }
+    const connectedIds = new Set(
+      (session.connectedTeams ?? []).map((t) => t.id)
+    );
+    console.log(
+      chalk.dim(
+        `Active: ${session.accountSlug || session.accountId} @ ${session.endpoint}`
+      )
+    );
+    console.log(
+      chalk.dim(
+        `Connected (CLI + MCP): ${(session.connectedTeams ?? []).map((t) => t.slug).join(", ") || "(none)"}`
+      )
+    );
+    for (const a of session.accounts) {
+      const mark = a.id === session.accountId ? chalk.green("*") : connectedIds.has(a.id) ? chalk.cyan("+") : " ";
+      console.log(
+        `${mark} ${a.slug.padEnd(24)}  ${a.name}${a.is_personal_account ? chalk.dim(" (personal)") : ""}`
+      );
+    }
+    console.log(chalk.dim("  * = active (CLI) \xB7 + = connected"));
+  });
+  brightsyCmd.command("switch").argument("<team>", "team id or slug").description("Connect/activate a team for CLI + MCP (alias of connect-team)").action(async (team) => {
+    const session = await switchBrightsyAccount(team);
+    const names = (session.connectedTeams ?? []).map((t) => t.slug).join(", ");
+    console.log(
+      chalk.green(
+        `Active: ${session.accountSlug || session.accountId} \xB7 connected: ${names}`
+      )
+    );
+  });
+  brightsyCmd.command("connect-team").argument("<team>", "team id or slug").description("Connect a team for Brightsy CLI + MCP (activates it for CLI)").action(async (team) => {
+    await connectBrightsyTeam(team);
+    const session = await getBrightsySession();
+    const names = (session.connectedTeams ?? []).map((t) => t.slug).join(", ");
+    console.log(
+      chalk.green(
+        `Active: ${session.accountSlug || session.accountId} \xB7 connected: ${names}`
+      )
+    );
+  });
+  brightsyCmd.command("disconnect-team").argument("<team>", "team id or slug").description("Disconnect a team from Brightsy CLI + MCP selection").action(async (team) => {
+    await disconnectBrightsyTeam(team);
+    const session = await getBrightsySession();
+    const names = (session.connectedTeams ?? []).map((t) => t.slug).join(", ");
+    console.log(
+      chalk.green(
+        names ? `Active: ${session.accountSlug || session.accountId} \xB7 connected: ${names}` : "No teams connected"
+      )
+    );
+  });
+  program.command("connect").description(
+    "Connect Sideboard to Brightsy cloud (Slack/Discord/Teams \u2014 poll inbound orchestrator tasks across all workspaces)"
+  ).option(
+    "--repo <path>",
+    "deprecated \u2014 ignored; cloud connect uses the Global workspace coordinator"
+  ).option("--agent <agent>", "claude|codex|opencode|cursor", "claude").option("--no-enable-access", "do not auto-enable Brightsy desktop access").option("--no-allow-always", "do not set allow_always when enabling access").option("--poll-ms <ms>", "poll interval", "5000").action(async (opts) => {
+    const agent = parseAgent(opts.agent);
+    if (agent === "brightsy") {
+      throw new Error(
+        "connect coordinator cannot use brightsy \u2014 use claude, codex, opencode, or cursor"
+      );
+    }
+    const ac = new AbortController();
+    const stop = () => ac.abort();
+    process.on("SIGINT", stop);
+    process.on("SIGTERM", stop);
+    console.log(
+      chalk.bold("Sideboard \u2194 Brightsy"),
+      chalk.dim("(Ctrl+C to stop)")
+    );
+    await runCloudConnect({
+      agent,
+      enableAccess: opts.enableAccess !== false,
+      allowAlways: opts.allowAlways !== false,
+      pollIntervalMs: Number(opts.pollMs) || 5e3,
+      signal: ac.signal,
+      onLog: (line) => console.log(chalk.dim(line))
+    });
+  });
+  program.command("branches").description("List branches in a repo").option("--repo <path>", "repo path", process.cwd()).option("--all", "include branches already merged into the default branch").action(async (opts) => {
+    const repo = await resolveRepoRoot(opts.repo);
+    const branches = await listBranches(repo, { unmergedOnly: !opts.all });
+    for (const b of branches) {
+      console.log(`${b.current ? "*" : " "} ${b.name}${b.remote ? " (remote)" : ""}`);
+    }
+  });
+  program.command("prs").option("--repo <path>", "repo path", process.cwd()).action(async (opts) => {
+    const repo = await resolveRepoRoot(opts.repo);
+    const prs = await listPrs(repo);
+    for (const p of prs) {
+      console.log(
+        `#${p.number}  ${p.title}  ${p.headRefName}${p.isCrossRepository ? " [fork]" : ""}`
+      );
+    }
+  });
+  program.command("issues").option("--repo <path>", "repo path", process.cwd()).option(
+    "--agent <agent>",
+    "legacy: list via agent Linear MCP (claude|codex|opencode). Omit to use Account connections."
+  ).action(async (opts) => {
+    const repo = await resolveRepoRoot(opts.repo);
+    if (opts.agent) {
+      const issues = await listLinearIssues(parseAgent(opts.agent), repo);
+      console.log(JSON.stringify(issues, null, 2));
+      return;
+    }
+    const result = await listIssues(repo);
+    console.log(JSON.stringify(result, null, 2));
+  });
+  await program.parseAsync(process.argv);
+}
+function statusColor(status) {
+  switch (status) {
+    case "running":
+      return chalk.green(status.padEnd(9));
+    case "queued":
+      return chalk.yellow(status.padEnd(9));
+    case "error":
+    case "broken":
+      return chalk.red(status.padEnd(9));
+    case "archived":
+      return chalk.dim(status.padEnd(9));
+    default:
+      return status.padEnd(9);
+  }
+}
+main().catch((err) => {
+  console.error(chalk.red(err instanceof Error ? err.message : String(err)));
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "@sideboard-ai/cli",
+  "version": "0.1.9",
+  "description": "Sideboard CLI — agent-agnostic worktree orchestration (includes `sideboard mcp`)",
+  "license": "Apache-2.0",
+  "type": "module",
+  "bin": {
+    "sideboard": "./dist/index.js",
+    "side": "./dist/index.js"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "dependencies": {
+    "chalk": "^5.4.1",
+    "commander": "^13.1.0",
+    "ora": "^8.2.0",
+    "@sideboard-ai/core": "0.1.9"
+  },
+  "devDependencies": {
+    "@types/node": "^22.13.10",
+    "tsup": "^8.4.0",
+    "tsx": "^4.19.3",
+    "typescript": "^5.8.2",
+    "vitest": "^3.0.9"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/mattlevine/sideboard.git",
+    "directory": "packages/cli"
+  },
+  "keywords": [
+    "sideboard",
+    "cli",
+    "mcp",
+    "agents",
+    "worktree"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "start": "tsx src/index.ts",
+    "dev": "tsx watch src/index.ts",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run --passWithNoTests"
+  }
+}