@motir/cli 0.0.1 → 0.1.0

package/dist/index.js

@@ -0,0 +1,3770 @@
+#!/usr/bin/env node
+
+// src/program.ts
+import { Command as Command2 } from "commander";
+
+// src/version.ts
+var CLI_VERSION = "0.1.0";
+
+// src/mcpClient.ts
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import {
+  StreamableHTTPClientTransport,
+  StreamableHTTPError
+} from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+
+// src/errors.ts
+var CliError = class extends Error {
+  exitCode;
+  /** An optional one-line hint shown under the error (e.g. how to recover). */
+  hint;
+  constructor(message, opts = {}) {
+    super(message);
+    this.name = "CliError";
+    this.exitCode = opts.exitCode ?? 1;
+    this.hint = opts.hint;
+  }
+};
+var AuthError = class extends CliError {
+  constructor(message = "Token invalid or expired.") {
+    super(message, { exitCode: 1, hint: "Run `motir auth login` to authenticate." });
+    this.name = "AuthError";
+  }
+};
+var NotLinkedError = class extends CliError {
+  constructor() {
+    super("No Motir project link found in this directory or any parent.", {
+      exitCode: 1,
+      hint: "Run `motir link` at your workspace root to bind a project."
+    });
+    this.name = "NotLinkedError";
+  }
+};
+
+// src/config/userConfig.ts
+import { homedir } from "os";
+import { join } from "path";
+import { chmodSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+var EMPTY = { tokens: {} };
+function normalizeServerUrl(url) {
+  return url.trim().replace(/\/+$/, "");
+}
+function configDir() {
+  const base = process.env["MOTIR_CONFIG_HOME"] || process.env["XDG_CONFIG_HOME"] || join(homedir(), ".config");
+  return join(base, "motir");
+}
+function configPath() {
+  return join(configDir(), "config.json");
+}
+function stateDir() {
+  const base = process.env["MOTIR_STATE_HOME"] || process.env["MOTIR_CONFIG_HOME"] || process.env["XDG_STATE_HOME"] || join(homedir(), ".local", "state");
+  return join(base, "motir");
+}
+function readUserConfig() {
+  const path = configPath();
+  if (!existsSync(path)) return { tokens: {} };
+  try {
+    const parsed = JSON.parse(readFileSync(path, "utf8"));
+    const config = { tokens: parsed.tokens ?? {} };
+    if (typeof parsed.agentCommand === "string") config.agentCommand = parsed.agentCommand;
+    return config;
+  } catch {
+    return { ...EMPTY, tokens: {} };
+  }
+}
+function writeUserConfig(config) {
+  const dir = configDir();
+  mkdirSync(dir, { recursive: true, mode: 448 });
+  const path = configPath();
+  writeFileSync(path, JSON.stringify(config, null, 2) + "\n", { mode: 384 });
+  chmodSync(path, 384);
+}
+function getCredential(serverUrl) {
+  return readUserConfig().tokens[normalizeServerUrl(serverUrl)];
+}
+var TOKEN_ENV_VAR = "MOTIR_TOKEN";
+var SERVER_ENV_VAR = "MOTIR_SERVER";
+function envValue(name) {
+  const raw = process.env[name];
+  if (typeof raw !== "string") return void 0;
+  const trimmed = raw.trim();
+  return trimmed ? trimmed : void 0;
+}
+function envToken() {
+  return envValue(TOKEN_ENV_VAR);
+}
+function envServerUrl() {
+  const value = envValue(SERVER_ENV_VAR);
+  return value ? normalizeServerUrl(value) : void 0;
+}
+function credentialOriginLabel(source) {
+  return source === "environment" ? `environment (${TOKEN_ENV_VAR})` : configPath();
+}
+function resolveCredential(serverUrl) {
+  const token = envToken();
+  if (token) return { token, source: "environment", origin: credentialOriginLabel("environment") };
+  const stored = getCredential(serverUrl);
+  if (!stored) return void 0;
+  return { ...stored, source: "config", origin: credentialOriginLabel("config") };
+}
+function setCredential(serverUrl, credential) {
+  const config = readUserConfig();
+  config.tokens[normalizeServerUrl(serverUrl)] = credential;
+  writeUserConfig(config);
+}
+function removeCredential(serverUrl) {
+  const config = readUserConfig();
+  const key = normalizeServerUrl(serverUrl);
+  if (!(key in config.tokens)) return false;
+  delete config.tokens[key];
+  writeUserConfig(config);
+  return true;
+}
+function getAgentCommand() {
+  const value = readUserConfig().agentCommand?.trim();
+  return value ? value : void 0;
+}
+function listServers() {
+  return Object.keys(readUserConfig().tokens);
+}
+function displayTokenPrefix(token) {
+  const head = token.slice(0, 14);
+  return token.length > head.length ? `${head}\u2026` : head;
+}
+
+// src/mcpClient.ts
+function textOf(result) {
+  return (result.content ?? []).filter((p) => p.type === "text" && typeof p.text === "string").map((p) => p.text).join("\n").trim();
+}
+function isUnauthorized(err) {
+  if (err instanceof StreamableHTTPError) return err.code === 401;
+  const message = err instanceof Error ? err.message : String(err);
+  return /\b401\b|unauthorized/i.test(message);
+}
+function mcpEndpoint(serverUrl) {
+  return new URL("/api/mcp", normalizeServerUrl(serverUrl) + "/");
+}
+var MotirClient = class {
+  serverUrl;
+  token;
+  client = null;
+  transport = null;
+  constructor(opts) {
+    this.serverUrl = normalizeServerUrl(opts.serverUrl);
+    this.token = opts.token;
+  }
+  /** Open the connection. A 401 (bad/revoked/expired PAT) → {@link AuthError}. */
+  async connect() {
+    if (this.client) return;
+    const transport = new StreamableHTTPClientTransport(mcpEndpoint(this.serverUrl), {
+      requestInit: { headers: { Authorization: `Bearer ${this.token}` } }
+    });
+    const client = new Client({ name: "motir-cli", version: CLI_VERSION });
+    try {
+      await client.connect(transport);
+    } catch (err) {
+      if (isUnauthorized(err)) throw new AuthError();
+      throw new CliError(`Could not reach the Motir server at ${this.serverUrl}: ${errMsg(err)}`);
+    }
+    this.client = client;
+    this.transport = transport;
+  }
+  async close() {
+    await this.client?.close();
+    await this.transport?.close();
+    this.client = null;
+    this.transport = null;
+  }
+  requireClient() {
+    if (!this.client) throw new CliError("MCP client used before connect().");
+    return this.client;
+  }
+  /** The server's advertised tool names — the `auth login` validation probe. */
+  async listToolNames() {
+    try {
+      const { tools } = await this.requireClient().listTools();
+      return tools.map((t) => t.name);
+    } catch (err) {
+      throw this.mapCallError(err);
+    }
+  }
+  /**
+   * Call a tool and return its `structuredContent` typed as `T`. A tool that
+   * comes back `isError` throws a {@link CliError} carrying the tool's own
+   * `code: message` text — never a swallowed JSON-RPC error. Unauthorized →
+   * {@link AuthError}.
+   */
+  async callStructured(name, args = {}) {
+    let result;
+    try {
+      result = await this.requireClient().callTool({
+        name,
+        arguments: args
+      });
+    } catch (err) {
+      throw this.mapCallError(err);
+    }
+    if (result.isError) {
+      throw new CliError(textOf(result) || `Tool ${name} failed.`);
+    }
+    return result.structuredContent;
+  }
+  mapCallError(err) {
+    if (err instanceof CliError) return err;
+    if (isUnauthorized(err)) return new AuthError();
+    return new CliError(errMsg(err));
+  }
+  // ── Typed tool wrappers ──────────────────────────────────────────────────
+  // These name the MCP tools the CLI consumes. Listing/auth/link commands use
+  // `whoami`; the read (7.9.2) and dispatch (7.9.3) commands use the rest.
+  whoami() {
+    return this.callStructured("whoami");
+  }
+  listReady(args) {
+    return this.callStructured("list_ready", { ...args });
+  }
+  nextReady(args) {
+    return this.callStructured("next_ready", { ...args });
+  }
+  getWorkItem(key) {
+    return this.callStructured("get_work_item", { key });
+  }
+  transitionStatus(args) {
+    return this.callStructured("transition_status", { ...args });
+  }
+  /**
+   * The CANONICAL, server-generated prompt for one item (MOTIR-1802). A pure
+   * READ — it never claims the item or moves its status, so re-printing an
+   * in-progress item's prompt is safe. The CLI prints this text verbatim; it
+   * never assembles a prompt grammar of its own.
+   *
+   * `sessionBranch` is the unattended-run SEED (`motir auto`, MOTIR-882): the
+   * branch to use when the item carries no lineage of its own. The server treats
+   * it as a fallback only — an item already on a lineage keeps that one — so the
+   * CLI can start a run's first item on the run's branch without ever being able
+   * to redirect an existing chain.
+   */
+  dispatchPrompt(key, opts = {}) {
+    return this.callStructured("dispatch_prompt", {
+      key,
+      ...opts.sessionBranch ? { sessionBranch: opts.sessionBranch } : {}
+    });
+  }
+  /** Record an item's work as integrated on a session branch (7.8.11): moves it
+   * to `in_review` AND stamps `session_branch` in one transaction. */
+  markIntegrated(args) {
+    return this.callStructured("mark_integrated", { ...args });
+  }
+  /** Bulk close-out for a merged session PR (7.8.11): every item recorded on
+   * the branch → done, `session_branch` cleared, with per-item outcomes. */
+  completeSession(args) {
+    return this.callStructured("complete_session", { ...args });
+  }
+  /**
+   * Submit an AI expansion of one CONTAINER item (MOTIR-1825) and return the
+   * moment the job is accepted — `{ jobId, planId }`, no streaming, no poll.
+   *
+   * There is deliberately no REST fallback here: expansion also has a
+   * cookie-authed `POST /api/ai/expand`, but the CLI is an MCP client only (the
+   * Story 7.9 header — one auth path), so the tool IS the mechanism.
+   *
+   * Firing this does NOT grow the tree. `motir auto --include-planning` calls it
+   * for an unexpanded epic/story and moves on; what comes back is a plan awaiting
+   * a human's approval in Motir.
+   */
+  expandItem(key) {
+    return this.callStructured("expand_item", { key });
+  }
+  /**
+   * Open — or RESUME — the planning conversation for a scope, and read its
+   * thread (MOTIR-1832).
+   *
+   * Addressed by SCOPE (`projectKey` + optional `targetKeys`), never by a
+   * session id: re-opening the same anchor set returns the SAME row the web
+   * panel is looking at, so the CLI cannot fork a second conversation about the
+   * same items. Opening submits nothing and costs nothing.
+   */
+  openPlanSession(args) {
+    return this.callStructured("open_plan_session", { ...args });
+  }
+  /**
+   * Add ONE turn to the conversation. APPENDING IS NOT SUBMITTING — the turn is
+   * server-side the moment this returns (so quitting can never lose it) and no
+   * job starts, no credits are spent, and no work item changes.
+   */
+  appendPlanTurn(args) {
+    return this.callStructured("append_plan_turn", { ...args });
+  }
+  /**
+   * Send the thread's ACCUMULATED intent — every turn, in order — as ONE change,
+   * returning `{ jobId, planId }` the moment the job is accepted.
+   *
+   * This does NOT create work items: the job produces a plan of PROPOSALS, and
+   * approving that plan in Motir is the only thing that turns one into a work
+   * item. A thread with no turns is refused by the server; a failed submit
+   * leaves the thread intact.
+   */
+  submitPlanSession(args) {
+    return this.callStructured("submit_plan_session", { ...args });
+  }
+  /** What became of a submitted planning job (MOTIR-1825) — the plan's status
+   *  AND, while it is still generating, whether the job is alive or already
+   *  dead (a failed job leaves the plan generating forever). */
+  getPlanStatus(args) {
+    return this.callStructured("get_plan_status", { ...args });
+  }
+  /** Read a plan WITH its proposals (MOTIR-1837) — what was proposed, not just
+   *  how many. Still PROPOSALS: nothing here exists in the tree. */
+  getPlan(args) {
+    return this.callStructured("get_plan", { ...args });
+  }
+  listSprints(args) {
+    return this.callStructured("list_sprints", { ...args });
+  }
+  searchWorkItems(args) {
+    return this.callStructured("search_work_items", { ...args });
+  }
+};
+function errMsg(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+
+// src/output.ts
+function out(line = "") {
+  process.stdout.write(line + "\n");
+}
+function info(line = "") {
+  process.stderr.write(line + "\n");
+}
+function outVerbatim(text) {
+  process.stdout.write(text.endsWith("\n") ? text : text + "\n");
+}
+function json(value) {
+  process.stdout.write(JSON.stringify(value, null, 2) + "\n");
+}
+
+// src/prompts.ts
+import { createInterface } from "readline";
+function isInteractive() {
+  return Boolean(process.stdin.isTTY && process.stderr.isTTY);
+}
+function promptLine(question, defaultValue) {
+  const suffix = defaultValue ? ` [${defaultValue}]` : "";
+  const rl = createInterface({ input: process.stdin, output: process.stderr });
+  return new Promise((resolve3) => {
+    rl.question(`${question}${suffix}: `, (answer) => {
+      rl.close();
+      const trimmed = answer.trim();
+      resolve3(trimmed.length > 0 ? trimmed : defaultValue ?? "");
+    });
+  });
+}
+function promptLineOrNull(question) {
+  const rl = createInterface({ input: process.stdin, output: process.stderr });
+  return new Promise((resolve3) => {
+    let answered = false;
+    rl.question(`${question}`, (answer) => {
+      answered = true;
+      rl.close();
+      resolve3(answer);
+    });
+    rl.on("close", () => {
+      if (!answered) resolve3(null);
+    });
+  });
+}
+function promptSecret(question) {
+  const rl = createInterface({ input: process.stdin, output: process.stderr });
+  rl._writeToOutput = () => {
+  };
+  process.stderr.write(`${question}: `);
+  return new Promise((resolve3) => {
+    rl.question("", (answer) => {
+      rl.close();
+      process.stderr.write("\n");
+      resolve3(answer.trim());
+    });
+  });
+}
+
+// src/config/linkConfig.ts
+import { dirname, isAbsolute, join as join2, resolve } from "path";
+import { existsSync as existsSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
+var LINK_FILENAME = ".motir.json";
+function isLinkConfig(value) {
+  if (!value || typeof value !== "object") return false;
+  const v = value;
+  return typeof v["serverUrl"] === "string" && typeof v["workspace"] === "string" && typeof v["project"] === "string";
+}
+function findLink(startDir = process.cwd()) {
+  let dir = resolve(startDir);
+  for (; ; ) {
+    const path = join2(dir, LINK_FILENAME);
+    if (existsSync2(path)) {
+      const parsed = JSON.parse(readFileSync2(path, "utf8"));
+      if (!isLinkConfig(parsed)) {
+        throw new NotLinkedError();
+      }
+      return { dir, path, config: parsed };
+    }
+    const parent = dirname(dir);
+    if (parent === dir) return null;
+    dir = parent;
+  }
+}
+function requireLink(startDir = process.cwd()) {
+  const found = findLink(startDir);
+  if (!found) throw new NotLinkedError();
+  return found;
+}
+function writeLink(dir, config) {
+  const path = join2(dir, LINK_FILENAME);
+  writeFileSync2(path, JSON.stringify(config, null, 2) + "\n");
+  return path;
+}
+function resolveRepo(rootDir, config, repoName) {
+  const override = config.repos?.[repoName];
+  let path;
+  let source;
+  if (override !== void 0) {
+    path = isAbsolute(override) ? override : resolve(rootDir, override);
+    source = "override";
+  } else {
+    path = resolve(rootDir, repoName);
+    source = "convention";
+  }
+  return { repoName, path, source, exists: existsSync2(path) };
+}
+function overrideRepoNames(config) {
+  return Object.keys(config.repos ?? {}).sort();
+}
+function withRepoOverride(config, repoName, path) {
+  return { ...config, repos: { ...config.repos ?? {}, [repoName]: path } };
+}
+function withoutRepoOverride(config, repoName) {
+  if (config.repos?.[repoName] === void 0) {
+    throw new Error(`No override for repo "${repoName}".`);
+  }
+  const next = { ...config.repos ?? {} };
+  delete next[repoName];
+  const result = { ...config };
+  if (Object.keys(next).length > 0) result.repos = next;
+  else delete result.repos;
+  return result;
+}
+
+// src/serverResolve.ts
+var DEFAULT_SERVER_URL = "https://app.motir.co";
+function resolveServerUrl(explicit) {
+  if (explicit) return normalizeServerUrl(explicit);
+  const fromEnv = envServerUrl();
+  if (fromEnv) return fromEnv;
+  const link = findLink();
+  if (link) return normalizeServerUrl(link.config.serverUrl);
+  const servers = listServers();
+  if (servers.length === 1) return servers[0];
+  if (servers.length === 0) return DEFAULT_SERVER_URL;
+  if (servers.some((stored) => stored === DEFAULT_SERVER_URL)) return DEFAULT_SERVER_URL;
+  throw new CliError("Multiple servers are configured; pass --server <url> to choose one.", {
+    hint: `Configured: ${servers.join(", ")}`
+  });
+}
+
+// src/commands/auth.ts
+async function authLogin(opts) {
+  let serverUrl = opts.server;
+  if (!serverUrl) {
+    if (!isInteractive()) {
+      throw new CliError("No server URL given.", { hint: "Pass --server <url>." });
+    }
+    serverUrl = await promptLine("Server URL", DEFAULT_SERVER_URL);
+  }
+  serverUrl = normalizeServerUrl(serverUrl);
+  let token = opts.token ?? envToken();
+  if (!token) {
+    if (!isInteractive()) {
+      throw new CliError("No token given.", {
+        hint: "Pass --token <pat>, set MOTIR_TOKEN, or run interactively."
+      });
+    }
+    token = await promptSecret("Personal access token");
+  }
+  if (!token) throw new CliError("A token is required.");
+  const client = new MotirClient({ serverUrl, token });
+  try {
+    await client.connect();
+    await client.listToolNames();
+    const who = await client.whoami();
+    setCredential(serverUrl, { token, user: who.user });
+    const ws = who.workspace ? ` (workspace ${who.workspace.name})` : "";
+    info(`Logged in as ${who.user.email} on ${serverUrl}${ws}.`);
+  } finally {
+    await client.close();
+  }
+}
+async function authStatus(opts) {
+  const serverUrl = resolveServerUrl(opts.server);
+  const cred = resolveCredential(serverUrl);
+  if (!cred) {
+    throw new CliError(`Not logged in to ${serverUrl}.`, {
+      hint: `Run \`motir auth login\`, or set ${TOKEN_ENV_VAR}.`
+    });
+  }
+  out(`Server:    ${serverUrl}`);
+  out(`Token:     ${displayTokenPrefix(cred.token)}`);
+  out(`Source:    ${cred.origin}`);
+  const client = new MotirClient({ serverUrl, token: cred.token });
+  try {
+    await client.connect();
+    const who = await client.whoami();
+    out(`User:      ${who.user.name || who.user.email} <${who.user.email}>`);
+    if (who.workspace) out(`Workspace: ${who.workspace.name} (${who.workspace.slug})`);
+  } finally {
+    await client.close();
+  }
+}
+async function authLogout(opts) {
+  const serverUrl = resolveServerUrl(opts.server);
+  const removed = removeCredential(serverUrl);
+  if (removed) info(`Logged out of ${serverUrl}.`);
+  else info(`No stored credential for ${serverUrl}.`);
+  if (envToken()) {
+    info(`${TOKEN_ENV_VAR} is still set \u2014 it overrides the stored credential. Unset it to finish.`);
+  }
+}
+
+// src/commands/link.ts
+function tokenFor(serverUrl) {
+  const cred = resolveCredential(serverUrl);
+  if (!cred) {
+    throw new CliError(`Not logged in to ${serverUrl}.`, {
+      hint: "Run `motir auth login`, or set MOTIR_TOKEN."
+    });
+  }
+  return cred.token;
+}
+async function assertProjectAccessible(client, projectKey) {
+  try {
+    await client.listReady({ projectKey, limit: 1 });
+  } catch (err) {
+    if (err instanceof CliError) {
+      throw new CliError(`Project "${projectKey}" is not accessible with this token.`, {
+        hint: "Check the project key, or your token\u2019s workspace."
+      });
+    }
+    throw err;
+  }
+}
+async function linkCommand(opts) {
+  const cwd = process.cwd();
+  const existing = findLink(cwd);
+  const noBindingFlags = !opts.server && !opts.workspace && !opts.project && !opts.repo;
+  if (existing && noBindingFlags) {
+    showLink(existing.dir, existing.config);
+    return;
+  }
+  const serverUrl = resolveServerUrl(opts.server ?? existing?.config.serverUrl);
+  const token = tokenFor(serverUrl);
+  const client = new MotirClient({ serverUrl, token });
+  try {
+    await client.connect();
+    const who = await client.whoami();
+    const workspace = opts.workspace ?? existing?.config.workspace ?? who.workspace?.slug;
+    if (!workspace) {
+      throw new CliError("Could not determine the workspace.", {
+        hint: "Pass --workspace <slug>."
+      });
+    }
+    let project = opts.project ?? existing?.config.project;
+    if (!project) {
+      if (!isInteractive()) {
+        throw new CliError("No project given.", { hint: "Pass --project <key>." });
+      }
+      project = await promptLine("Project key");
+    }
+    if (!project) throw new CliError("A project key is required.");
+    await assertProjectAccessible(client, project);
+    const config = {
+      serverUrl,
+      workspace,
+      project,
+      ...existing?.config.repos ? { repos: { ...existing.config.repos } } : {}
+    };
+    const withRepo = opts.repo ? withRepoOverride(config, opts.repo, ".") : config;
+    const targetDir = existing?.dir ?? cwd;
+    const path = writeLink(targetDir, withRepo);
+    info(`Linked ${targetDir} \u2192 ${workspace}/${project} on ${serverUrl}`);
+    info(`Wrote ${path}`);
+    showLink(targetDir, withRepo);
+  } finally {
+    await client.close();
+  }
+}
+function linkAddCommand(repo, path) {
+  const found = requireLink();
+  const next = withRepoOverride(found.config, repo, path);
+  writeLink(found.dir, next);
+  info(`Override set: ${repo} \u2192 ${path}`);
+  showLink(found.dir, next);
+}
+function linkRemoveCommand(repo) {
+  const found = requireLink();
+  let next;
+  try {
+    next = withoutRepoOverride(found.config, repo);
+  } catch {
+    throw new CliError(`No override for repo "${repo}".`);
+  }
+  writeLink(found.dir, next);
+  info(`Override removed: ${repo}`);
+  showLink(found.dir, next);
+}
+function showLink(rootDir, config) {
+  out(`Root:      ${rootDir}`);
+  out(`Server:    ${config.serverUrl}`);
+  out(`Workspace: ${config.workspace}`);
+  out(`Project:   ${config.project}`);
+  const names = overrideRepoNames(config);
+  if (names.length === 0) {
+    out("Repos:     (none listed) \u2014 checkouts resolve by convention <root>/<repoName>");
+    return;
+  }
+  out("Repos:");
+  for (const name of names) {
+    const r = resolveRepo(rootDir, config, name);
+    const state = r.exists ? "exists" : "not yet";
+    out(`  ${name} \u2192 ${r.path}  [${r.source}, ${state}]`);
+  }
+}
+
+// src/render.ts
+var FILTER_VERSION = "v1";
+var IN_FLIGHT_STATUS_KEYS = ["in_progress", "in_review"];
+function inFlightFilter() {
+  return {
+    version: FILTER_VERSION,
+    combinator: "and",
+    conditions: [{ field: "status", operator: "is_any_of", value: [...IN_FLIGHT_STATUS_KEYS] }]
+  };
+}
+function sprintFilter(sprintId, kinds) {
+  const conditions = [
+    { field: "sprint", operator: "is_any_of", value: [sprintId] }
+  ];
+  if (kinds && kinds.length > 0) {
+    conditions.push({ field: "kind", operator: "is_any_of", value: kinds });
+  }
+  return { version: FILTER_VERSION, combinator: "and", conditions };
+}
+function issueUrl(serverUrl, key) {
+  return `${normalizeServerUrl(serverUrl)}/issues/${encodeURIComponent(key)}`;
+}
+function truncate(text, max) {
+  if (max <= 1) return text.slice(0, Math.max(0, max));
+  return text.length > max ? text.slice(0, max - 1) + "\u2026" : text;
+}
+function formatTable(headers, rows, opts = {}) {
+  const right = new Set(opts.rightAlign ?? []);
+  const widths = headers.map(
+    (h, col) => Math.max(h.length, ...rows.map((r) => (r[col] ?? "").length))
+  );
+  const pad = (cell, col) => {
+    const w = widths[col] ?? cell.length;
+    return right.has(col) ? cell.padStart(w) : cell.padEnd(w);
+  };
+  const line = (cells) => cells.map((c, col) => pad(c, col)).join("  ").trimEnd();
+  const header = line(headers);
+  const underline = widths.map((w) => "\u2500".repeat(w)).join("  ");
+  return [header, underline, ...rows.map(line)].join("\n");
+}
+var TERMINAL_STATUS_KEYS = ["done", "cancelled"];
+function isSatisfiedBlocker(status) {
+  return TERMINAL_STATUS_KEYS.includes(status);
+}
+var EDGE_KEYS_BUDGET = 3;
+var SATISFIED_MARK = "\u2713";
+var EXTERNAL_MARK = "\u2197";
+var MARK_LEGEND = [
+  [SATISFIED_MARK, `${SATISFIED_MARK} = already done`],
+  [EXTERNAL_MARK, `${EXTERNAL_MARK} = blocker outside this parent`]
+];
+function markLegend(cells) {
+  const shown = MARK_LEGEND.filter(([mark]) => cells.some((cell) => cell.includes(mark)));
+  return shown.length > 0 ? shown.map(([, text]) => text).join(" \xB7 ") : null;
+}
+function overflowKeys(keys, budget) {
+  if (keys.length === 0) return "";
+  if (keys.length <= budget) return keys.join(", ");
+  return `${keys.slice(0, budget).join(", ")} +${keys.length - budget}`;
+}
+function edgeCell(edges, budget = EDGE_KEYS_BUDGET) {
+  if (!edges) return "";
+  const live = edges.filter((e) => !isSatisfiedBlocker(e.status)).map((e) => e.key);
+  const settled = edges.filter((e) => isSatisfiedBlocker(e.status)).map((e) => `${e.key}${SATISFIED_MARK}`);
+  return overflowKeys([...live, ...settled], budget);
+}
+function hasEdges(rows) {
+  return rows.length > 0 && rows.every((row) => row.dependencies !== void 0);
+}
+function withLegend(table, cells) {
+  const legend = markLegend(cells);
+  return legend ? `${table}
+${legend}` : table;
+}
+var READY_HEADERS = ["KEY", "KIND", "PRIORITY", "ASSIGNEE", "TITLE"];
+var READY_EDGE_HEADERS = ["KEY", "KIND", "PRIORITY", "ASSIGNEE", "BLOCKS", "TITLE"];
+function renderReadyTable(items, titleWidth = 60) {
+  if (items.length === 0) return "No ready work items.";
+  const graphed = hasEdges(items);
+  const rows = items.map((it) => [
+    it.key,
+    it.kind,
+    it.priority,
+    it.assignee?.name ?? "unassigned",
+    ...graphed ? [edgeCell(it.dependencies?.blocks)] : [],
+    truncate(it.title, titleWidth)
+  ]);
+  const count = `${items.length} ready work item${items.length === 1 ? "" : "s"}:`;
+  const headers = graphed ? READY_EDGE_HEADERS : READY_HEADERS;
+  const table = `${count}
+${formatTable(headers, rows)}`;
+  return graphed ? withLegend(
+    table,
+    rows.map((row) => row[4] ?? "")
+  ) : table;
+}
+function formatSprintWindow(sprint) {
+  if (!sprint.startDate && !sprint.endDate) return "";
+  return `${sprint.startDate ?? "\u2014"} \u2192 ${sprint.endDate ?? "\u2014"}`;
+}
+var NONE = "\u2014";
+var SPRINTS_HEADERS = ["", "STATE", "NAME", "ITEMS", "POINTS", "WINDOW"];
+function renderSprintsTable(sprints, nameWidth = 40) {
+  if (sprints.length === 0) return "No sprints.";
+  const ordered = [...sprints].sort((a, b) => a.sequence - b.sequence);
+  const rows = ordered.map((s) => [
+    s.state === "active" ? "*" : "",
+    s.state,
+    truncate(s.name, nameWidth),
+    String(s.issueCount),
+    s.committedPoints === null ? NONE : String(s.committedPoints),
+    formatSprintWindow(s) || NONE
+  ]);
+  const count = `${ordered.length} sprint${ordered.length === 1 ? "" : "s"}:`;
+  return `${count}
+${formatTable(SPRINTS_HEADERS, rows, { rightAlign: [3, 4] })}`;
+}
+function renderSprintHeader(sprint) {
+  const lines = [`${sprint.name}  [${sprint.state}]`];
+  const window = formatSprintWindow(sprint);
+  if (window) lines.push(window);
+  if (sprint.goal) lines.push(`goal: ${sprint.goal}`);
+  if (sprint.committedIssueCount !== null || sprint.committedPoints !== null) {
+    const issues = sprint.committedIssueCount === null ? NONE : String(sprint.committedIssueCount);
+    const points = sprint.committedPoints === null ? NONE : String(sprint.committedPoints);
+    lines.push(`committed: ${issues} issues \xB7 ${points} points`);
+  }
+  return lines.join("\n");
+}
+var SPRINT_ITEM_HEADERS = ["KEY", "KIND", "STATUS", "PRIORITY", "TITLE"];
+var SPRINT_ITEM_EDGE_HEADERS = [
+  "KEY",
+  "KIND",
+  "STATUS",
+  "PRIORITY",
+  "BLOCKED BY",
+  "BLOCKS",
+  "TITLE"
+];
+function renderSprintItems(items, total, titleWidth = 60) {
+  if (items.length === 0) return "No work items in this sprint.";
+  const graphed = hasEdges(items);
+  const rows = items.map((it) => [
+    it.identifier,
+    it.kind,
+    it.status,
+    it.priority,
+    ...graphed ? [edgeCell(it.dependencies?.blockedBy), edgeCell(it.dependencies?.blocks)] : [],
+    truncate(it.title, titleWidth)
+  ]);
+  const noun = `work item${total === 1 ? "" : "s"}`;
+  const count = items.length === total ? `${total} ${noun}:` : `${items.length} of ${total} ${noun} (the rest could not be collected):`;
+  const headers = graphed ? SPRINT_ITEM_EDGE_HEADERS : SPRINT_ITEM_HEADERS;
+  const table = `${count}
+${formatTable(headers, rows)}`;
+  return graphed ? withLegend(
+    table,
+    rows.flatMap((row) => [row[4] ?? "", row[5] ?? ""])
+  ) : table;
+}
+function resolveSprintRef(sprints, ref) {
+  if (ref === void 0 || ref.trim() === "") {
+    const active = sprints.find((s) => s.state === "active");
+    if (active) return active;
+    throw new CliError("No sprint is active in this project.", {
+      hint: "Run `motir sprints` to see every sprint, then `motir sprint <name>`."
+    });
+  }
+  const needle = ref.trim();
+  const byId = sprints.find((s) => s.id === needle);
+  if (byId) return byId;
+  const lower = needle.toLowerCase();
+  const byName = sprints.filter((s) => s.name.toLowerCase() === lower);
+  if (byName.length === 1) return byName[0];
+  const byPrefix = byName.length > 0 ? byName : sprints.filter(prefixMatch(lower));
+  if (byPrefix.length === 1) return byPrefix[0];
+  if (byPrefix.length > 1) {
+    throw new CliError(`"${needle}" matches ${byPrefix.length} sprints.`, {
+      hint: `Name one of: ${byPrefix.map((s) => s.name).join(", ")}.`
+    });
+  }
+  throw new CliError(`No sprint matches "${needle}".`, {
+    hint: "Run `motir sprints` to see this project\u2019s sprints (a name, a name prefix, or an id)."
+  });
+}
+function prefixMatch(lower) {
+  return (sprint) => sprint.name.toLowerCase().startsWith(lower);
+}
+function renderStatusBlock(pulse) {
+  const lines = [
+    `Project:    ${pulse.projectKey}`,
+    `Ready:      ${pulse.readyCount}`,
+    `In flight:  ${pulse.inFlightCount}  (in progress + in review)`
+  ];
+  if (pulse.activeSprint) {
+    const s = pulse.activeSprint;
+    lines.push(
+      `Sprint:     ${s.name}  [active, ${s.issueCount} issue${s.issueCount === 1 ? "" : "s"}]`
+    );
+    const window = formatSprintWindow(s);
+    if (window) lines.push(`            ${window}`);
+    if (s.goal) lines.push(`            goal: ${s.goal}`);
+  } else if (pulse.totalSprints === 0) {
+    lines.push("Sprint:     (no sprints)");
+  } else {
+    lines.push("Sprint:     (none active)");
+  }
+  return lines.join("\n");
+}
+var CHILD_HEADERS = ["KEY", "KIND", "STATUS", "TITLE"];
+var EDGE_HEADERS = ["KEY", "STATUS", "TITLE"];
+function childRow(child, titleWidth = 60) {
+  return [child.identifier, child.kind, child.status, truncate(child.title, titleWidth)];
+}
+function childRows(children, titleWidth = 60) {
+  return children.map((child) => childRow(child, titleWidth));
+}
+function edgeRows(links, titleWidth = 60) {
+  return links.map(({ item }) => [item.identifier, item.status, truncate(item.title, titleWidth)]);
+}
+function renderRelationTable(heading, rows, emptyLine, headers = EDGE_HEADERS, note) {
+  const title = `${heading} (${rows.length})`;
+  if (rows.length === 0) return `${title}
+${emptyLine}`;
+  return `${note ? `${title} \u2014 ${note}` : title}
+${formatTable(headers, rows)}`;
+}
+function assignChildWaves(children) {
+  const siblingKeys = new Set(children.map((c) => c.identifier));
+  const classified = children.map((child) => {
+    const entry = {
+      child,
+      wave: null,
+      siblingBlockers: [],
+      externalBlockers: [],
+      satisfiedBlockers: []
+    };
+    for (const edge of child.dependencies?.blockedBy ?? []) {
+      if (isSatisfiedBlocker(edge.status)) entry.satisfiedBlockers.push(edge.key);
+      else if (siblingKeys.has(edge.key)) entry.siblingBlockers.push(edge.key);
+      else entry.externalBlockers.push(edge.key);
+    }
+    return entry;
+  });
+  const placed = /* @__PURE__ */ new Map();
+  const ordered = [];
+  let remaining = classified;
+  for (let wave = 1; remaining.length > 0; wave += 1) {
+    const ready = remaining.filter((e) => e.siblingBlockers.every((k) => placed.has(k)));
+    if (ready.length === 0) break;
+    for (const entry of ready) {
+      entry.wave = wave;
+      ordered.push(entry);
+    }
+    for (const entry of ready) placed.set(entry.child.identifier, wave);
+    remaining = remaining.filter((e) => !placed.has(e.child.identifier));
+  }
+  return [...ordered, ...remaining];
+}
+function cycleMembers(waves) {
+  return waves.filter((w) => w.wave === null).map((w) => w.child.identifier);
+}
+var WAVE_CHILD_HEADERS = ["WAVE", "KEY", "KIND", "STATUS", "BLOCKED BY", "TITLE"];
+var NO_WAVE = "\u2014";
+function blockedByCell(entry, budget = EDGE_KEYS_BUDGET) {
+  return overflowKeys(
+    [
+      ...entry.siblingBlockers,
+      ...entry.externalBlockers.map((k) => `${k}${EXTERNAL_MARK}`),
+      ...entry.satisfiedBlockers.map((k) => `${k}${SATISFIED_MARK}`)
+    ],
+    budget
+  );
+}
+function waveChildRows(waves, titleWidth = 60, budget = EDGE_KEYS_BUDGET) {
+  return waves.map((entry) => {
+    const cells = childRow(entry.child, titleWidth);
+    const wave = entry.wave === null ? NO_WAVE : String(entry.wave);
+    return [wave, ...cells.slice(0, 3), blockedByCell(entry, budget), ...cells.slice(3)];
+  });
+}
+function renderChildrenSection(children, titleWidth = 60) {
+  if (!hasEdges(children)) {
+    return renderRelationTable(
+      "CHILDREN",
+      childRows(children, titleWidth),
+      "no children",
+      CHILD_HEADERS
+    );
+  }
+  const waves = assignChildWaves(children);
+  const rows = waveChildRows(waves, titleWidth);
+  const lines = [
+    renderRelationTable("CHILDREN", rows, "no children", WAVE_CHILD_HEADERS, "build order")
+  ];
+  const legend = markLegend(rows.map((row) => row[4] ?? ""));
+  if (legend) lines.push(legend);
+  const cycle = cycleMembers(waves);
+  if (cycle.length > 0) {
+    lines.push(
+      `\u26A0 dependency CYCLE \u2014 ${cycle.join(", ")} block each other and have no build order. Fix the blocked_by edges.`
+    );
+  }
+  return lines.join("\n");
+}
+function detailWithWaves(detail) {
+  if (!hasEdges(detail.children)) return detail;
+  return {
+    ...detail,
+    children: assignChildWaves(detail.children).map((entry) => ({
+      ...entry.child,
+      wave: entry.wave
+    }))
+  };
+}
+function renderItemHeader(item) {
+  const kindType = item.type ? `${item.kind}/${item.type}` : item.kind;
+  const fields = [`status ${item.status}`, `priority ${item.priority}`];
+  const add = (label, value) => {
+    if (value !== null) fields.push(`${label} ${value}`);
+  };
+  add("assignee", item.assigneeId);
+  add("type", item.type);
+  add("executor", item.executor);
+  add("points", item.storyPoints);
+  add("estimate", item.estimateMinutes === null ? null : `${item.estimateMinutes}m`);
+  add("sprint", item.sprintId);
+  add("repo", item.targetRepo);
+  return `${item.identifier}  [${kindType}]  ${item.title}
+${fields.join(" \xB7 ")}`;
+}
+function renderReadinessLine(readiness) {
+  if (readiness.ready) return "ready";
+  if (readiness.openBlockers.length > 0) {
+    return `blocked by ${readiness.openBlockers.map((b) => b.identifier).join(", ")}`;
+  }
+  const ancestor = readiness.blockedByAncestor;
+  if (ancestor) return `blocked by ancestor ${ancestor.identifier} \u2014 ${ancestor.title}`;
+  return "blocked";
+}
+function renderLineage(detail) {
+  return [...detail.ancestors.map((a) => a.identifier), detail.item.identifier].join(" \u203A ");
+}
+function renderWorkItemDetail(detail, titleWidth = 60) {
+  const sections = [
+    renderItemHeader(detail.item),
+    `READINESS
+${renderReadinessLine(detail.readiness)}`,
+    `LINEAGE
+${renderLineage(detail)}`,
+    renderChildrenSection(detail.children, titleWidth),
+    renderRelationTable("BLOCKED BY", edgeRows(detail.blockedBy, titleWidth), "none"),
+    renderRelationTable("BLOCKS", edgeRows(detail.blocks, titleWidth), "none"),
+    renderRelationTable("RELATES TO", edgeRows(detail.relatesTo, titleWidth), "none")
+  ];
+  const body = detail.item.descriptionMd;
+  if (body) sections.push(`DESCRIPTION
+${body.trimEnd()}`);
+  return sections.join("\n\n");
+}
+
+// src/session.ts
+async function openProjectSession() {
+  const link = requireLink();
+  const serverUrl = resolveServerUrl();
+  const cred = resolveCredential(serverUrl);
+  if (!cred) {
+    throw new CliError(`Not logged in to ${serverUrl}.`, {
+      hint: "Run `motir auth login`, or set MOTIR_TOKEN."
+    });
+  }
+  const client = new MotirClient({ serverUrl, token: cred.token });
+  await client.connect();
+  return { link, serverUrl, projectKey: link.config.project, client };
+}
+async function withProjectSession(fn) {
+  const session = await openProjectSession();
+  try {
+    return await fn(session);
+  } finally {
+    await session.client.close();
+  }
+}
+var READY_PAGE_SIZE = 200;
+async function collectReady(client, projectKey, filter = {}) {
+  const all = [];
+  let cursor;
+  do {
+    const page = await client.listReady({
+      projectKey,
+      kinds: filter.kinds,
+      assigneeId: filter.assigneeId,
+      cursor,
+      limit: READY_PAGE_SIZE
+    });
+    all.push(...page.items);
+    cursor = page.nextCursor ?? void 0;
+  } while (cursor);
+  return all;
+}
+var SEARCH_PAGE_SIZE = 50;
+async function collectSprintItems(client, projectKey, sprintId, filter = {}) {
+  const items = [];
+  let cursor;
+  let total = 0;
+  do {
+    const page = await client.searchWorkItems({
+      projectKey,
+      filter: sprintFilter(sprintId, filter.kinds),
+      cursor,
+      limit: SEARCH_PAGE_SIZE
+    });
+    items.push(...page.items);
+    total = page.total;
+    cursor = page.nextCursor ?? void 0;
+  } while (cursor);
+  return { items, total };
+}
+
+// src/browser.ts
+import { spawn } from "child_process";
+function launcher(platform) {
+  if (platform === "darwin") return { cmd: "open", args: [] };
+  if (platform === "win32") return { cmd: "cmd", args: ["/c", "start", ""] };
+  return { cmd: "xdg-open", args: [] };
+}
+function hasDisplay(env, platform) {
+  if (platform === "darwin" || platform === "win32") return true;
+  return Boolean(env["DISPLAY"] || env["WAYLAND_DISPLAY"]);
+}
+function openUrl(url, opts = {}) {
+  const platform = opts.platform ?? process.platform;
+  const env = opts.env ?? process.env;
+  if (!hasDisplay(env, platform)) return Promise.resolve(false);
+  const { cmd, args } = launcher(platform);
+  return new Promise((resolve3) => {
+    try {
+      const child = spawn(cmd, [...args, url], { stdio: "ignore", detached: true });
+      child.on("error", () => resolve3(false));
+      child.unref();
+      setTimeout(() => resolve3(true), 0);
+    } catch {
+      resolve3(false);
+    }
+  });
+}
+
+// src/commands/read.ts
+var WORK_ITEM_KINDS = /* @__PURE__ */ new Set(["epic", "story", "task", "bug", "subtask"]);
+function parseKinds(raw) {
+  if (!raw) return void 0;
+  const kinds = raw.split(",").map((k) => k.trim().toLowerCase()).filter((k) => k.length > 0);
+  if (kinds.length === 0) return void 0;
+  const bad = kinds.filter((k) => !WORK_ITEM_KINDS.has(k));
+  if (bad.length > 0) {
+    throw new CliError(`Unknown work item kind(s): ${bad.join(", ")}.`, {
+      hint: `Valid kinds: ${[...WORK_ITEM_KINDS].join(", ")}.`
+    });
+  }
+  return kinds;
+}
+async function resolveAssignee(client, raw) {
+  if (raw === void 0) return void 0;
+  const value = raw.trim().toLowerCase();
+  if (value === "unassigned" || value === "none") return "unassigned";
+  if (value === "me") {
+    const who = await client.whoami();
+    return who.user.id;
+  }
+  return raw;
+}
+async function readyCommand(opts) {
+  const kinds = parseKinds(opts.kinds);
+  await withProjectSession(async ({ client, projectKey }) => {
+    const assigneeId = await resolveAssignee(client, opts.assignee);
+    const items = await collectReady(client, projectKey, { kinds, assigneeId });
+    if (opts.json) {
+      json(items);
+      return;
+    }
+    out(renderReadyTable(items));
+  });
+}
+async function statusCommand(opts) {
+  const pulse = await withProjectSession(async ({ client, projectKey }) => {
+    const ready = await collectReady(client, projectKey);
+    const search = await client.searchWorkItems({
+      projectKey,
+      filter: inFlightFilter(),
+      limit: 1
+    });
+    const { sprints } = await client.listSprints({ projectKey });
+    const result = {
+      projectKey,
+      readyCount: ready.length,
+      inFlightCount: search.total,
+      activeSprint: sprints.find((s) => s.state === "active") ?? null,
+      totalSprints: sprints.length
+    };
+    return result;
+  });
+  if (opts.json) {
+    json(pulse);
+    return;
+  }
+  out(renderStatusBlock(pulse));
+}
+var SPRINT_STATES = /* @__PURE__ */ new Set(["planned", "active", "complete"]);
+function parseSprintState(raw) {
+  if (raw === void 0) return void 0;
+  const state = raw.trim().toLowerCase();
+  if (state === "") return void 0;
+  if (!SPRINT_STATES.has(state)) {
+    throw new CliError(`Unknown sprint state: ${raw.trim()}.`, {
+      hint: `Valid states: ${[...SPRINT_STATES].join(", ")}.`
+    });
+  }
+  return state;
+}
+async function sprintsCommand(opts) {
+  const state = parseSprintState(opts.state);
+  const sprints = await withProjectSession(async ({ client, projectKey }) => {
+    const list = await client.listSprints({ projectKey });
+    return state ? list.sprints.filter((s) => s.state === state) : list.sprints;
+  });
+  if (opts.json) {
+    json(sprints);
+    return;
+  }
+  out(renderSprintsTable(sprints));
+}
+async function sprintCommand(ref, opts) {
+  const kinds = parseKinds(opts.kinds);
+  const result = await withProjectSession(async ({ client, projectKey }) => {
+    const { sprints } = await client.listSprints({ projectKey });
+    const sprint = resolveSprintRef(sprints, ref);
+    const { items, total } = await collectSprintItems(client, projectKey, sprint.id, { kinds });
+    return { sprint, items, total };
+  });
+  if (opts.json) {
+    json(result);
+    return;
+  }
+  out(renderSprintHeader(result.sprint));
+  out();
+  out(renderSprintItems(result.items, result.total));
+}
+var ITEM_KEY = /^[A-Za-z][A-Za-z0-9_]*-\d+$/;
+function parseItemKey(raw, command) {
+  const key = raw.trim().toUpperCase();
+  if (!ITEM_KEY.test(key)) {
+    throw new CliError(`"${raw.trim()}" is not a work item key.`, {
+      hint: `Keys look like PROD-7. Run \`motir ${command} PROD-7\`, or \`motir ready\` to list what you can pick up.`
+    });
+  }
+  return key;
+}
+async function showCommand(key, opts) {
+  const identifier = parseItemKey(key, "show");
+  const detail = await withProjectSession(({ client }) => client.getWorkItem(identifier));
+  if (opts.json) {
+    json(detailWithWaves(detail));
+    return;
+  }
+  out(renderWorkItemDetail(detail));
+}
+async function openCommand(key, opts) {
+  const trimmed = key.trim();
+  if (!trimmed) throw new CliError("A work item key is required, e.g. `motir open PROD-7`.");
+  const link = requireLink();
+  const url = issueUrl(link.config.serverUrl, trimmed);
+  out(url);
+  if (opts.print) return;
+  const launched = await openUrl(url);
+  if (!launched) info("(Could not open a browser here \u2014 the URL is above.)");
+}
+
+// src/commands/doctor.ts
+import { homedir as homedir2 } from "os";
+import { accessSync, constants, existsSync as existsSync3, statSync } from "fs";
+import { delimiter, isAbsolute as isAbsolute2, join as join4, resolve as resolve2 } from "path";
+import { execFile } from "child_process";
+
+// src/agentProfiles.ts
+import { basename, join as join3 } from "path";
+var sandboxAgentConfigHome = (home) => join3(home, ".motir-sandbox", "agent-config");
+var AGENT_PROFILES = [
+  {
+    id: "claude",
+    label: "Claude Code",
+    tier: 1,
+    binaries: ["claude"],
+    installSource: "npm install -g @anthropic-ai/claude-code",
+    credentialPaths: ({ home }) => [join3(home, ".claude")],
+    credentialEnv: ["ANTHROPIC_API_KEY"],
+    credentialKnown: true,
+    credentialHint: "Run `claude` once to sign in, or set ANTHROPIC_API_KEY.",
+    codegraphTarget: "claude",
+    codegraphConfig: {
+      // Claude Code reads its MCP servers from <CLAUDE_CONFIG_DIR>/.claude.json
+      // — by default ~/.claude/.claude.json, INSIDE the `:ro` mount. (The
+      // ~/.claude.json codegraph writes is a legacy path the shipped 2.x CLI no
+      // longer reads at all — verified, which is why this profile had no tools
+      // rather than merely no permission list.) The entrypoint redirects
+      // CLAUDE_CONFIG_DIR to the image-owned home, seeds it from the mount and
+      // merges codegraph's stanza into the copy.
+      mcpServers: ({ home }) => join3(sandboxAgentConfigHome(home), ".claude", ".claude.json"),
+      // The auto-allow list is a SEPARATE file from the server list here, and
+      // it moves with the same redirect.
+      autoAllow: ({ home }) => join3(sandboxAgentConfigHome(home), ".claude", "settings.json"),
+      redirect: {
+        env: "CLAUDE_CONFIG_DIR",
+        why: "CLAUDE_CONFIG_DIR governs the state file, settings.json, CLAUDE.md AND .credentials.json, so the redirected dir is seeded from the read-only mount before codegraph merges into it."
+      },
+      knownAutoAllowGap: null
+    }
+  },
+  {
+    id: "codex",
+    label: "Codex CLI",
+    tier: 1,
+    binaries: ["codex"],
+    installSource: "npm install -g @openai/codex",
+    credentialPaths: ({ home }) => [join3(home, ".codex")],
+    credentialEnv: ["OPENAI_API_KEY"],
+    credentialKnown: true,
+    credentialHint: "Run `codex` once to sign in, or set OPENAI_API_KEY.",
+    codegraphTarget: "codex",
+    codegraphConfig: {
+      // codegraph's default target is ~/.codex/config.toml — INSIDE the `:ro`
+      // mount, so the host copy shadowed it and the agent saw no tools at all.
+      // The entrypoint redirects CODEX_HOME to the image-owned home, seeds it
+      // from the mount and lets codegraph merge its stanza into the copy.
+      mcpServers: ({ home }) => join3(sandboxAgentConfigHome(home), ".codex", "config.toml"),
+      // config.toml carries the server AND its trust/approval settings.
+      autoAllow: null,
+      redirect: {
+        env: "CODEX_HOME",
+        why: "CODEX_HOME governs config.toml AND auth.json, so the redirected home is seeded from the read-only mount before codegraph merges into it."
+      },
+      knownAutoAllowGap: null
+    }
+  },
+  {
+    id: "opencode",
+    label: "OpenCode",
+    tier: 1,
+    binaries: ["opencode"],
+    installSource: "npm, or the OpenCode install script (opencode.ai)",
+    // OpenCode SPLITS the two: `~/.config/opencode` holds configuration, while
+    // the credential is `auth.json` under the XDG DATA home — which is why the
+    // sandbox mounts both dirs. Testing the config dir passed on any machine
+    // that had ever run opencode, signed in or not; the check is the auth FILE.
+    credentialPaths: ({ xdgDataHome }) => [join3(xdgDataHome, "opencode", "auth.json")],
+    credentialEnv: [],
+    credentialKnown: true,
+    credentialHint: "Run `opencode auth login` to sign in \u2014 it writes auth.json.",
+    codegraphTarget: "opencode",
+    codegraphConfig: {
+      // codegraph's default target is ~/.config/opencode/opencode.jsonc —
+      // INSIDE the `:ro` config mount. OPENCODE_CONFIG is MERGED on top of the
+      // global config rather than replacing it (verified), so pointing it at the
+      // image-owned copy adds the codegraph stanza while the host's own config
+      // keeps applying, and the credential (XDG data dir) is untouched.
+      mcpServers: ({ home }) => join3(sandboxAgentConfigHome(home), ".config", "opencode", "opencode.jsonc"),
+      autoAllow: null,
+      redirect: {
+        env: "OPENCODE_CONFIG",
+        why: "OPENCODE_CONFIG merges over the global config, so no credential is copied and the host config still applies."
+      },
+      knownAutoAllowGap: null
+    }
+  },
+  {
+    id: "kimi",
+    label: "Kimi Code CLI",
+    tier: 1,
+    binaries: ["kimi"],
+    installSource: "npm (@moonshot-ai/kimi-code) \u2014 needs Node \u2265 22.19",
+    credentialPaths: ({ home }) => [join3(home, ".kimi-code")],
+    credentialEnv: [],
+    credentialKnown: true,
+    credentialHint: "Run `kimi` once to sign in \u2014 it writes ~/.kimi-code.",
+    codegraphTarget: null,
+    codegraphConfig: null
+  },
+  {
+    id: "antigravity",
+    label: "Antigravity CLI",
+    tier: 2,
+    // The installer links `agy`, not `antigravity`; the profile id is kept as a
+    // tolerated alias for anyone who aliased it that way.
+    binaries: ["agy", "antigravity"],
+    installSource: "curl -fsSL https://antigravity.google/cli/install.sh | bash",
+    // `agy` keeps its token in the OS KEYRING, with no documented portable
+    // file — the one profile with genuinely nowhere to look (the sandbox
+    // mounts no credential for it either).
+    credentialPaths: () => [],
+    credentialEnv: [],
+    credentialKnown: false,
+    credentialHint: "Sign in with `agy` (its token lives in the OS keyring, not a file).",
+    codegraphTarget: "antigravity",
+    codegraphConfig: {
+      // This profile mounts NO credential directory at all, so nothing can
+      // shadow the wiring.
+      mcpServers: ({ home }) => join3(home, ".gemini", "antigravity", "mcp_config.json"),
+      autoAllow: null,
+      redirect: null,
+      knownAutoAllowGap: null
+    }
+  },
+  {
+    id: "cursor",
+    label: "Cursor CLI",
+    tier: 2,
+    // The installer symlinks the executable as `agent`, keeping `cursor-agent`
+    // as the legacy alias — `cursor` is neither, and matched nothing until the
+    // list arrived. It stays last so a user who aliased it keeps a profile.
+    binaries: ["agent", "cursor-agent", "cursor"],
+    installSource: "curl https://cursor.com/install -fsS | bash",
+    // The matrix's `~/.local/share/cursor-agent` mount is also where the
+    // installer unpacks the CLI itself, so its presence proves an INSTALL, not
+    // a sign-in. The API key is the one unambiguous signal, so it is the only
+    // one tested.
+    credentialPaths: () => [],
+    credentialEnv: ["CURSOR_API_KEY"],
+    credentialKnown: true,
+    credentialHint: "Run `cursor-agent login` to sign in, or set CURSOR_API_KEY.",
+    codegraphTarget: "cursor",
+    codegraphConfig: {
+      // Cursor's credential mount is ~/.local/share/cursor-agent, which does not
+      // contain ~/.cursor — the wiring is clear of it without a redirect.
+      mcpServers: ({ home }) => join3(home, ".cursor", "mcp.json"),
+      autoAllow: null,
+      redirect: null,
+      knownAutoAllowGap: null
+    }
+  },
+  {
+    id: "aider",
+    label: "Aider",
+    tier: 2,
+    binaries: ["aider"],
+    installSource: "pip (Python) \u2014 PyPI `aider-chat`",
+    // Aider's credential IS the model key it reads from the environment. Its
+    // `~/.aider.conf.yml` is configuration, and the sandbox asks the user to
+    // create it (even empty) so docker can bind it — so its presence would
+    // prove nothing at all.
+    credentialPaths: () => [],
+    credentialEnv: ["ANTHROPIC_API_KEY", "OPENAI_API_KEY"],
+    credentialKnown: true,
+    credentialHint: "Give Aider a model key: set ANTHROPIC_API_KEY or OPENAI_API_KEY.",
+    codegraphTarget: null,
+    codegraphConfig: null
+  },
+  {
+    id: "goose",
+    label: "Goose",
+    tier: 2,
+    binaries: ["goose"],
+    installSource: "the Goose installer (Block)",
+    // Goose stores provider secrets in the OS KEYRING by default and only falls
+    // back to a file under `~/.config/goose` when the keyring is disabled (as
+    // the sandbox does). Neither state is testable from outside: an existing
+    // config dir need not hold a key, and a keyring-backed key leaves no file.
+    credentialPaths: () => [],
+    credentialEnv: [],
+    credentialKnown: false,
+    credentialHint: "Run `goose configure` to store a provider key.",
+    codegraphTarget: null,
+    codegraphConfig: null
+  }
+];
+function parseAgentCommand(command) {
+  const trimmed = (command ?? "").trim();
+  if (!trimmed) return null;
+  const boundary = trimmed.search(/\s/);
+  if (boundary === -1) return { command: trimmed, binary: trimmed, args: [] };
+  return {
+    command: trimmed,
+    binary: trimmed.slice(0, boundary),
+    args: trimmed.slice(boundary + 1).trim().split(/\s+/)
+  };
+}
+function findAgentProfile(binary) {
+  const name = basename(binary).toLowerCase().replace(/\.(exe|cmd|bat|ps1)$/, "");
+  return AGENT_PROFILES.find((p) => p.binaries.includes(name)) ?? null;
+}
+
+// src/doctor.ts
+function credentialDirs(probe) {
+  return {
+    home: probe.home(),
+    xdgConfigHome: probe.xdgConfigHome(),
+    xdgDataHome: probe.xdgDataHome()
+  };
+}
+var AGENT_SOURCE_LABEL = {
+  flag: "--agent",
+  env: "MOTIR_AGENT",
+  config: "config agentCommand"
+};
+function resolveAgentCommand(opts, probe) {
+  const flag = opts.agent?.trim();
+  if (flag) return { command: flag, source: "flag" };
+  const env = probe.agentEnvOverride()?.trim();
+  if (env) return { command: env, source: "env" };
+  const configured = probe.configuredAgentCommand()?.trim();
+  if (configured) return { command: configured, source: "config" };
+  return null;
+}
+function credentialLocations(profile, probe) {
+  const paths = profile.credentialPaths(credentialDirs(probe));
+  return [...paths, ...profile.credentialEnv.map((name) => `the ${name} env var`)];
+}
+async function runDoctor(opts, probe) {
+  const checks = [];
+  const link = probe.findLink();
+  checks.push(
+    link ? {
+      id: "link",
+      label: "Project link",
+      status: "pass",
+      detail: `${link.config.project} in ${link.config.workspace} \xB7 ${link.path}`
+    } : {
+      id: "link",
+      label: "Project link",
+      status: "fail",
+      detail: "No .motir.json found in this directory or any parent.",
+      remediation: "Run `motir link` at your workspace root to bind a project."
+    }
+  );
+  let serverUrl = null;
+  let serverError = null;
+  try {
+    serverUrl = probe.resolveServerUrl();
+  } catch (err) {
+    serverError = err instanceof CliError ? { message: err.message, ...err.hint ? { hint: err.hint } : {} } : { message: err instanceof Error ? err.message : String(err) };
+  }
+  const credentialOrigin = serverUrl ? probe.credentialOrigin(serverUrl) : null;
+  let server = null;
+  if (serverUrl && credentialOrigin) {
+    const projectKey = link?.config.project;
+    server = await probe.probeServer({
+      serverUrl,
+      ...projectKey ? { projectKey } : {}
+    });
+  }
+  checks.push(authCheck({ serverUrl, serverError, server, credentialOrigin }));
+  checks.push(projectCheck({ link, server }));
+  checks.push(reposCheck(link, probe));
+  const agent = resolveAgentCommand(opts, probe);
+  const parsed = agent ? parseAgentCommand(agent.command) : null;
+  const profile = parsed ? findAgentProfile(parsed.binary) : null;
+  if (!agent || !parsed) {
+    checks.push({
+      id: "agent",
+      label: "Coding agent",
+      status: "warn",
+      detail: "No coding agent configured.",
+      remediation: 'Pass --agent <cmd>, set MOTIR_AGENT, or add "agentCommand" to the user config. (`motir next --print` needs no agent \u2014 it hands you the prompt.)'
+    });
+    checks.push({
+      id: "credential",
+      label: "Agent credential",
+      status: "warn",
+      detail: "Skipped \u2014 no coding agent configured.",
+      remediation: "Configure an agent first, then re-run `motir doctor`."
+    });
+    return summarize(checks);
+  }
+  const probed = await probe.probeAgent(parsed.binary);
+  checks.push(agentCheck({ parsed, source: agent.source, profile, probed }));
+  checks.push(credentialCheck({ binary: parsed.binary, profile, probe }));
+  return summarize(checks);
+}
+function authCheck(input) {
+  const { serverUrl, serverError, server, credentialOrigin } = input;
+  const base = { id: "auth", label: "Auth" };
+  if (!serverUrl) {
+    return {
+      ...base,
+      status: "fail",
+      detail: serverError?.message ?? "No Motir server configured.",
+      remediation: serverError?.hint ?? "Run `motir auth login` first."
+    };
+  }
+  if (!server) {
+    return {
+      ...base,
+      status: "fail",
+      detail: `Not logged in to ${serverUrl}.`,
+      remediation: "Run `motir auth login` to store a personal access token, or set MOTIR_TOKEN (no file needed \u2014 the tier CI and the sandbox use)."
+    };
+  }
+  if (!server.ok) {
+    return {
+      ...base,
+      status: "fail",
+      detail: `${serverUrl}: ${server.error?.message ?? "the server could not be reached."}`,
+      remediation: server.error?.hint ?? "Run `motir auth login` to re-authenticate."
+    };
+  }
+  const who = server.user ? `${server.user.email}` : "unknown user";
+  const ws = server.workspace ? ` \xB7 workspace ${server.workspace.slug}` : "";
+  const tools = server.toolCount === void 0 ? "" : ` \xB7 ${server.toolCount} tools`;
+  const via = credentialOrigin ? ` \xB7 via ${credentialOrigin}` : "";
+  return { ...base, status: "pass", detail: `${who} on ${serverUrl}${ws}${tools}${via}` };
+}
+function projectCheck(input) {
+  const { link, server } = input;
+  const base = { id: "project", label: "Workspace + project" };
+  if (!link) {
+    return {
+      ...base,
+      status: "warn",
+      detail: "Skipped \u2014 no project link to resolve.",
+      remediation: "Run `motir link` first."
+    };
+  }
+  if (!server?.ok || !server.project) {
+    return {
+      ...base,
+      status: "warn",
+      detail: "Skipped \u2014 the server could not be reached.",
+      remediation: "Fix the auth check above, then re-run `motir doctor`."
+    };
+  }
+  const { project } = server;
+  if (!project.reachable) {
+    return {
+      ...base,
+      status: "fail",
+      detail: `Project ${project.key} is not reachable: ${project.error ?? "unknown error"}`,
+      remediation: `Check the project key in .motir.json, and that your token's user is a member of ${link.config.workspace}.`
+    };
+  }
+  const linked = link.config.workspace;
+  const active = server.workspace?.slug;
+  const count = project.total === void 0 ? "" : ` \xB7 ${project.total} work items`;
+  if (active && active !== linked) {
+    return {
+      ...base,
+      status: "warn",
+      detail: `${project.key} reachable${count}, but the token's active workspace is ${active}, not ${linked}.`,
+      remediation: `Confirm ${linked} is the workspace you meant to link.`
+    };
+  }
+  return { ...base, status: "pass", detail: `${project.key} in ${linked} reachable${count}` };
+}
+function reposCheck(link, probe) {
+  const base = { id: "repos", label: "Repo checkouts" };
+  if (!link) {
+    return {
+      ...base,
+      status: "warn",
+      detail: "Skipped \u2014 no project link to resolve.",
+      remediation: "Run `motir link` first."
+    };
+  }
+  const repos = probe.resolveRepos(link);
+  if (repos.length === 0) {
+    return {
+      ...base,
+      status: "pass",
+      detail: `No overrides \u2014 checkouts resolve by convention under ${link.dir}`
+    };
+  }
+  const missingOverrides = repos.filter((r) => r.source === "override" && !r.exists);
+  const summary = repos.map((r) => `${r.repoName} \u2192 ${r.path}${r.exists ? "" : " (not yet)"}`);
+  if (missingOverrides.length > 0) {
+    return {
+      ...base,
+      status: "warn",
+      detail: `${missingOverrides.length} override path(s) do not exist: ${summary.join(", ")}`,
+      remediation: "Fix with `motir link add <repo> <path>`, or clone the checkout there."
+    };
+  }
+  return { ...base, status: "pass", detail: summary.join(", ") };
+}
+function agentCheck(input) {
+  const { parsed, source, profile, probed } = input;
+  const base = { id: "agent", label: "Coding agent" };
+  const via = `via ${AGENT_SOURCE_LABEL[source]}`;
+  if (!probed.onPath) {
+    return {
+      ...base,
+      status: "fail",
+      detail: `\`${parsed.binary}\` (${via}) is not on PATH.`,
+      remediation: profile ? `Install ${profile.label}: ${profile.installSource}` : `Install \`${parsed.binary}\` and make sure it is on PATH (Motir runs your agent, it never bundles one).`
+    };
+  }
+  const where = probed.resolvedPath ? ` \u2192 ${probed.resolvedPath}` : "";
+  if (!probed.version) {
+    return {
+      ...base,
+      status: "warn",
+      detail: `\`${parsed.binary}\`${where} is on PATH but did not answer --version${probed.versionError ? ` (${probed.versionError})` : ""}.`,
+      remediation: "Run the agent once by hand to confirm it starts before `motir auto`."
+    };
+  }
+  const label = profile ? `${profile.label} ` : "";
+  return {
+    ...base,
+    status: "pass",
+    detail: `${label}\`${parsed.command}\` (${via})${where} \xB7 ${probed.version}`
+  };
+}
+function credentialCheck(input) {
+  const { binary, profile, probe } = input;
+  const base = { id: "credential", label: "Agent credential" };
+  if (!profile) {
+    return {
+      ...base,
+      status: "warn",
+      detail: `No credential profile for \`${binary}\` \u2014 Motir knows the sandbox-matrix agents only.`,
+      remediation: `Check \`${binary}\`'s own docs for where it stores its credential, and confirm it is signed in.`
+    };
+  }
+  if (!profile.credentialKnown) {
+    return {
+      ...base,
+      status: "warn",
+      detail: `${profile.label}'s credential location is not pinned by the profile matrix.`,
+      remediation: profile.credentialHint
+    };
+  }
+  const paths = profile.credentialPaths(credentialDirs(probe));
+  const foundPath = paths.find((p) => probe.pathExists(p));
+  if (foundPath) {
+    return {
+      ...base,
+      status: "pass",
+      detail: `${profile.label} credential present at ${foundPath} (presence only \u2014 never read).`
+    };
+  }
+  const foundEnv = profile.credentialEnv.find((name) => probe.hasEnv(name));
+  if (foundEnv) {
+    return {
+      ...base,
+      status: "pass",
+      detail: `${profile.label} credential present via ${foundEnv} (set \u2014 value never read).`
+    };
+  }
+  return {
+    ...base,
+    status: "fail",
+    detail: `No ${profile.label} credential found.`,
+    remediation: `${profile.credentialHint} Expected ${credentialLocations(profile, probe).join(" or ")}.`
+  };
+}
+function summarize(checks) {
+  return { ok: !checks.some((c) => c.status === "fail"), checks };
+}
+function doctorExitCode(report) {
+  return report.ok ? 0 : 1;
+}
+var STATUS_ORDER = ["fail", "warn", "pass"];
+function countByStatus(checks) {
+  const counts = { pass: 0, warn: 0, fail: 0 };
+  for (const check of checks) counts[check.status] += 1;
+  return counts;
+}
+function plural(n, one, many) {
+  return `${n} ${n === 1 ? one : many}`;
+}
+function renderDoctorReport(report) {
+  const labelWidth = Math.max(...report.checks.map((c) => c.label.length), 0);
+  const lines = ["motir doctor \u2014 BYOK preflight", ""];
+  for (const check of report.checks) {
+    lines.push(
+      `${check.status.toUpperCase().padEnd(4)}  ${check.label.padEnd(labelWidth)}  ${check.detail}`
+    );
+    if (check.remediation) lines.push(`${" ".repeat(6 + labelWidth + 2)}\u21B3 ${check.remediation}`);
+  }
+  const counts = countByStatus(report.checks);
+  const parts = STATUS_ORDER.filter((s) => counts[s] > 0).map(
+    (s) => s === "fail" ? plural(counts.fail, "failed", "failed") : s === "warn" ? plural(counts.warn, "warning", "warnings") : plural(counts.pass, "passed", "passed")
+  );
+  lines.push(
+    "",
+    report.ok ? `All hard checks passed \u2014 ${parts.join(", ")}.` : `${parts.join(", ")}.`
+  );
+  return lines.join("\n");
+}
+
+// src/commands/doctor.ts
+var AGENT_VERSION_TIMEOUT_MS = 5e3;
+async function probeServerWith(client, projectKey) {
+  try {
+    await client.connect();
+  } catch (err) {
+    return { ok: false, error: describeError(err) };
+  }
+  try {
+    const toolCount = (await client.listToolNames()).length;
+    const who = await client.whoami();
+    const result = {
+      ok: true,
+      toolCount,
+      user: { name: who.user.name, email: who.user.email },
+      workspace: who.workspace ? { name: who.workspace.name, slug: who.workspace.slug } : null
+    };
+    if (projectKey) {
+      try {
+        const page = await client.searchWorkItems({ projectKey, limit: 1 });
+        result.project = { key: projectKey, reachable: true, total: page.total };
+      } catch (err) {
+        result.project = { key: projectKey, reachable: false, error: describeError(err).message };
+      }
+    }
+    return result;
+  } catch (err) {
+    return { ok: false, error: describeError(err) };
+  } finally {
+    await client.close().catch(() => void 0);
+  }
+}
+function describeError(err) {
+  if (err instanceof CliError) {
+    return { message: err.message, ...err.hint ? { hint: err.hint } : {} };
+  }
+  return { message: err instanceof Error ? err.message : String(err) };
+}
+function isExecutableFile(path) {
+  try {
+    if (!statSync(path).isFile()) return false;
+    accessSync(path, constants.X_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function resolveOnPath(binary, env = process.env, platform = process.platform) {
+  const withExtensions = (base) => {
+    if (platform !== "win32") return [base];
+    const exts = (env["PATHEXT"] ?? ".COM;.EXE;.BAT;.CMD").split(";").filter(Boolean);
+    return [base, ...exts.map((ext) => base + ext)];
+  };
+  if (binary.includes("/") || binary.includes("\\")) {
+    const direct = isAbsolute2(binary) ? binary : resolve2(binary);
+    return withExtensions(direct).find(isExecutableFile) ?? null;
+  }
+  for (const dir of (env["PATH"] ?? "").split(delimiter).filter(Boolean)) {
+    const hit = withExtensions(join4(dir, binary)).find(isExecutableFile);
+    if (hit) return hit;
+  }
+  return null;
+}
+function firstLine(text) {
+  const newline = text.indexOf("\n");
+  return (newline === -1 ? text : text.slice(0, newline)).trim();
+}
+function probeAgentVersion(path) {
+  return new Promise((done) => {
+    execFile(
+      path,
+      ["--version"],
+      { timeout: AGENT_VERSION_TIMEOUT_MS, windowsHide: true },
+      (err, stdout, stderr) => {
+        if (err) {
+          done({ error: firstLine(err.message) });
+          return;
+        }
+        const text = firstLine(`${stdout}${stderr}`.trim());
+        done(text ? { version: text } : { error: "no output" });
+      }
+    );
+  });
+}
+function defaultDoctorProbe() {
+  return {
+    findLink: () => findLink(),
+    resolveServerUrl: () => resolveServerUrl(),
+    credentialOrigin: (serverUrl) => resolveCredential(serverUrl)?.origin ?? null,
+    probeServer: async ({ serverUrl, projectKey }) => {
+      const url = normalizeServerUrl(serverUrl);
+      const cred = resolveCredential(url);
+      if (!cred) return { ok: false, error: { message: `Not logged in to ${url}.` } };
+      const client = new MotirClient({ serverUrl: url, token: cred.token });
+      return probeServerWith(client, projectKey);
+    },
+    resolveRepos: (link) => overrideRepoNames(link.config).map((name) => resolveRepo(link.dir, link.config, name)),
+    probeAgent: async (binary) => {
+      const resolved = resolveOnPath(binary);
+      if (!resolved) return { onPath: false };
+      const { version, error } = await probeAgentVersion(resolved);
+      return {
+        onPath: true,
+        resolvedPath: resolved,
+        ...version ? { version } : {},
+        ...error ? { versionError: error } : {}
+      };
+    },
+    configuredAgentCommand: () => getAgentCommand(),
+    agentEnvOverride: () => process.env["MOTIR_AGENT"],
+    // PRESENCE predicates only — the credential itself is never opened, and an
+    // env var's VALUE is never returned. See doctor.ts's structural note.
+    pathExists: (path) => existsSync3(path),
+    hasEnv: (name) => {
+      const value = process.env[name];
+      return typeof value === "string" && value.length > 0;
+    },
+    home: () => homedir2(),
+    xdgConfigHome: () => process.env["XDG_CONFIG_HOME"] || join4(homedir2(), ".config"),
+    xdgDataHome: () => process.env["XDG_DATA_HOME"] || join4(homedir2(), ".local", "share")
+  };
+}
+async function doctorCommand(opts, probe = defaultDoctorProbe()) {
+  const report = await runDoctor(opts, probe);
+  if (opts.json) json(report);
+  else out(renderDoctorReport(report));
+  process.exitCode = doctorExitCode(report);
+}
+
+// src/agentRun.ts
+import { spawn as spawn2 } from "child_process";
+import { mkdtempSync, rmSync, writeFileSync as writeFileSync3 } from "fs";
+import { tmpdir } from "os";
+import { join as join5 } from "path";
+var PROMPT_FILE_MODE = 384;
+function defaultTempDir() {
+  return mkdtempSync(join5(tmpdir(), "motir-prompt-"));
+}
+async function runAgent(opts) {
+  const spawnFn = opts.spawnFn ?? spawn2;
+  const dir = (opts.tempDirFactory ?? defaultTempDir)();
+  const promptFile = join5(dir, "prompt.md");
+  writeFileSync3(promptFile, opts.prompt, { mode: PROMPT_FILE_MODE });
+  try {
+    return await new Promise((resolve3, reject) => {
+      const child = spawnFn(opts.command.binary, opts.command.args, {
+        cwd: opts.cwd,
+        // stdin piped (we write the prompt); stdout/stderr inherited so the
+        // agent's output streams straight through to the user's terminal.
+        stdio: ["pipe", "inherit", "inherit"],
+        env: { ...opts.env ?? process.env, MOTIR_PROMPT_FILE: promptFile }
+      });
+      child.on("error", (err) => {
+        reject(
+          err.code === "ENOENT" ? new CliError(`Could not launch the agent "${opts.command.binary}": not found.`, {
+            hint: "Run `motir doctor` to check your agent command and credentials."
+          }) : new CliError(`Could not launch the agent "${opts.command.binary}": ${err.message}`)
+        );
+      });
+      const stdin = child.stdin;
+      if (stdin) {
+        stdin.on("error", () => {
+        });
+        stdin.end(opts.prompt);
+      }
+      child.on("close", (code, signal) => {
+        resolve3({ exitCode: signal ? 1 : code ?? 1, signal });
+      });
+    });
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+}
+
+// src/sessionExcludes.ts
+import { join as join6 } from "path";
+import { existsSync as existsSync4, mkdirSync as mkdirSync2, readFileSync as readFileSync3, writeFileSync as writeFileSync4 } from "fs";
+var EXCLUDES_FILENAME = "session-excludes.json";
+function excludesPath() {
+  return join6(stateDir(), EXCLUDES_FILENAME);
+}
+function legacyExcludesPath() {
+  return join6(configDir(), EXCLUDES_FILENAME);
+}
+function scopeKey(serverUrl, projectKey) {
+  return `${normalizeServerUrl(serverUrl)}|${projectKey.toUpperCase()}`;
+}
+function readStore() {
+  const primary = excludesPath();
+  const path = existsSync4(primary) ? primary : legacyExcludesPath();
+  if (!existsSync4(path)) return {};
+  try {
+    const parsed = JSON.parse(readFileSync3(path, "utf8"));
+    if (!parsed || typeof parsed !== "object") return {};
+    return parsed;
+  } catch {
+    return {};
+  }
+}
+var warnedPaths = /* @__PURE__ */ new Set();
+function writeStore(store) {
+  const path = excludesPath();
+  try {
+    mkdirSync2(stateDir(), { recursive: true, mode: 448 });
+    writeFileSync4(path, JSON.stringify(store, null, 2) + "\n");
+    warnedPaths.delete(path);
+    return true;
+  } catch (err) {
+    if (!warnedPaths.has(path)) {
+      warnedPaths.add(path);
+      const reason = err instanceof Error ? err.message : String(err);
+      info(
+        `Note: could not write the session exclude list (${path}): ${reason}
+      Continuing \u2014 the list only avoids re-picking an item that just failed,
+      and a failed item is already held out of the ready set by its status.
+      Set MOTIR_STATE_HOME to a writable directory to persist it.`
+      );
+    }
+    return false;
+  }
+}
+function readExcludes(serverUrl, projectKey) {
+  return readStore()[scopeKey(serverUrl, projectKey)] ?? [];
+}
+function addExclude(serverUrl, projectKey, entry) {
+  const store = readStore();
+  const key = scopeKey(serverUrl, projectKey);
+  const current = store[key] ?? [];
+  if (current.some((e) => e.id === entry.id)) return;
+  store[key] = [...current, entry];
+  writeStore(store);
+}
+function removeExclude(serverUrl, projectKey, id) {
+  const store = readStore();
+  const key = scopeKey(serverUrl, projectKey);
+  const current = store[key] ?? [];
+  const next = current.filter((e) => e.id !== id);
+  if (next.length === current.length) return false;
+  if (next.length > 0) store[key] = next;
+  else delete store[key];
+  return writeStore(store);
+}
+function removeExcludeByKey(serverUrl, projectKey, key) {
+  const entry = readExcludes(serverUrl, projectKey).find(
+    (e) => e.key.toUpperCase() === key.toUpperCase()
+  );
+  return entry ? removeExclude(serverUrl, projectKey, entry.id) : false;
+}
+function clearExcludes(serverUrl, projectKey) {
+  const store = readStore();
+  const key = scopeKey(serverUrl, projectKey);
+  const count = store[key]?.length ?? 0;
+  if (count === 0) return 0;
+  delete store[key];
+  return writeStore(store) ? count : 0;
+}
+
+// src/dispatch.ts
+import { existsSync as existsSync5 } from "fs";
+function resolveDispatchTarget(rootDir, config, targetRepo, opts = {}) {
+  const exists = opts.exists ?? existsSync5;
+  if (!targetRepo) {
+    return {
+      targetRepo: null,
+      cwd: rootDir,
+      reason: "unpinned_root",
+      repoPath: null,
+      repoSource: null,
+      verifyCheckoutAfterRun: false
+    };
+  }
+  const resolved = resolveRepo(rootDir, config, targetRepo);
+  const present = exists(resolved.path);
+  return {
+    targetRepo,
+    cwd: present ? resolved.path : rootDir,
+    reason: present ? "repo_checkout" : "bootstrap_root",
+    repoPath: resolved.path,
+    repoSource: resolved.source,
+    verifyCheckoutAfterRun: !present
+  };
+}
+function checkBootstrapCheckout(target, opts = {}) {
+  const exists = opts.exists ?? existsSync5;
+  if (!target.verifyCheckoutAfterRun || !target.targetRepo || !target.repoPath) return null;
+  if (exists(target.repoPath)) return null;
+  return {
+    repoName: target.targetRepo,
+    expectedPath: target.repoPath,
+    message: `Suspect dispatch: the agent exited 0 but "${target.targetRepo}" still has no checkout at ${target.repoPath}.`,
+    hint: `If this repo lives elsewhere, run \`motir link add ${target.targetRepo} <path>\`.`
+  };
+}
+var AGENT_SOURCE_LABEL2 = {
+  flag: "--agent",
+  env: "MOTIR_AGENT",
+  config: "config agentCommand"
+};
+function agentSourceLabel(source) {
+  return AGENT_SOURCE_LABEL2[source];
+}
+function cwdReasonLabel(target) {
+  switch (target.reason) {
+    case "repo_checkout":
+      return `${target.targetRepo ?? ""} checkout (${target.repoSource})`;
+    case "bootstrap_root":
+      return `workspace root \u2014 no "${target.targetRepo ?? ""}" checkout yet, the prompt creates it`;
+    case "unpinned_root":
+      return "workspace root \u2014 the item pins no repo";
+  }
+}
+function workflowLabel(mode, sessionBranch) {
+  return mode === "session_lineage" ? `session lineage on ${sessionBranch ?? "(unnamed branch)"}` : "one pull request of its own";
+}
+function renderDispatchSummary(input) {
+  const { key, title, dispatch, target, agent } = input;
+  const lines = [
+    `Dispatch:   ${key}${title ? ` \u2014 ${title}` : ""}`,
+    `Repo:       ${dispatch.targetRepo ?? "not pinned (Motir cannot say)"}`,
+    `Path:       ${target.cwd}`,
+    `            ${cwdReasonLabel(target)}`,
+    `Workflow:   ${workflowLabel(dispatch.workflowMode, dispatch.sessionBranch)}`
+  ];
+  lines.push(
+    agent ? `Agent:      ${agent.command}  (${agentSourceLabel(agent.source)})` : "Agent:      none \u2014 printing the prompt (copy it into your agent)"
+  );
+  return lines.join("\n");
+}
+function renderAgentSuccess(key, dispatch) {
+  if (dispatch.workflowMode === "session_lineage" && dispatch.sessionBranch) {
+    return [
+      `${key}: agent finished \u2014 integrated on "${dispatch.sessionBranch}" (now In Review).`,
+      `Next: review + merge the session PR, then \`motir done --session ${dispatch.sessionBranch}\`.`
+    ].join("\n");
+  }
+  return [
+    `${key}: agent finished \u2014 its pull request should be open (now In Review).`,
+    `Next: review + merge the PR, then \`motir done ${key}\`.`
+  ].join("\n");
+}
+function renderAgentFailure(key, exitCode) {
+  return [
+    `${key}: agent exited ${exitCode}. The item stays In Progress (nothing was reverted).`,
+    `It is excluded from the next \`motir next\` in this session; re-run it with \`motir run ${key}\`.`
+  ].join("\n");
+}
+function renderSessionOutcomes(sessionBranch, results) {
+  if (results.length === 0) return `No work items are recorded on "${sessionBranch}".`;
+  const counts = results.reduce((acc, r) => {
+    acc[r.outcome] = (acc[r.outcome] ?? 0) + 1;
+    return acc;
+  }, {});
+  const head = `Completed session "${sessionBranch}": ` + Object.entries(counts).map(([outcome, n]) => `${n} ${outcome.replace("_", " ")}`).join(", ") + ".";
+  const detail = results.map((r) => `  ${r.key}: ${r.outcome}${r.reason ? ` \u2014 ${r.reason}` : ""}`);
+  return [head, ...detail].join("\n");
+}
+
+// src/commands/dispatch.ts
+var IN_PROGRESS = "in_progress";
+var IN_REVIEW = "in_review";
+var DONE = "done";
+var HARNESS = `motir-cli/${CLI_VERSION}`;
+function resolveAgent(opts, env = process.env, configured = getAgentCommand) {
+  if (opts.print) return null;
+  const candidates = [
+    [opts.agent, "flag"],
+    [env["MOTIR_AGENT"], "env"],
+    [configured(), "config"]
+  ];
+  for (const [raw, source] of candidates) {
+    const parsed = parseAgentCommand(raw);
+    if (parsed) return { parsed, source };
+  }
+  return null;
+}
+async function ensureInProgress(client, key, currentStatus) {
+  if (currentStatus === IN_PROGRESS) {
+    info(`${key}: already In Progress \u2014 leaving the status as it is.`);
+    return;
+  }
+  await client.transitionStatus({ key, status: IN_PROGRESS });
+}
+async function deliver(input) {
+  const { session, key, title, id, dispatch, opts } = input;
+  const { client, link, serverUrl, projectKey } = session;
+  const agent = resolveAgent(opts);
+  const target = resolveDispatchTarget(link.dir, link.config, dispatch.targetRepo);
+  const summary = renderDispatchSummary({
+    key,
+    title,
+    dispatch,
+    target,
+    agent: agent ? { command: agent.parsed.command, source: agent.source } : null
+  });
+  if (!agent) {
+    info(summary);
+    info("");
+    outVerbatim(dispatch.prompt);
+    return;
+  }
+  info(summary);
+  info("");
+  const result = await runAgent({
+    command: agent.parsed,
+    prompt: dispatch.prompt,
+    cwd: target.cwd
+  });
+  if (result.exitCode !== 0) {
+    if (id) addExclude(serverUrl, projectKey, { id, key });
+    info("");
+    info(renderAgentFailure(key, result.exitCode));
+    process.exitCode = result.exitCode;
+    return;
+  }
+  if (dispatch.workflowMode === "session_lineage" && dispatch.sessionBranch) {
+    await client.markIntegrated({
+      key,
+      sessionBranch: dispatch.sessionBranch,
+      implementationHarness: HARNESS
+    });
+  } else {
+    await client.transitionStatus({ key, status: IN_REVIEW });
+  }
+  if (id) removeExclude(serverUrl, projectKey, id);
+  const suspect = checkBootstrapCheckout(target);
+  info("");
+  info(renderAgentSuccess(key, dispatch));
+  if (suspect) {
+    info("");
+    info(suspect.message);
+    info(`Hint: ${suspect.hint}`);
+  }
+}
+async function nextCommand(opts) {
+  const kinds = parseKinds(opts.kinds);
+  await withProjectSession(async (session) => {
+    const { client, serverUrl, projectKey } = session;
+    if (opts.reset) {
+      const cleared = clearExcludes(serverUrl, projectKey);
+      info(`Cleared ${cleared} excluded item${cleared === 1 ? "" : "s"}.`);
+    }
+    const excluded = readExcludes(serverUrl, projectKey);
+    if (excluded.length > 0) {
+      info(`Skipping ${excluded.length} previously-failed item(s): ${keyList(excluded)}.`);
+    }
+    const { item } = await client.nextReady({
+      projectKey,
+      ...kinds ? { kinds } : {},
+      ...excluded.length > 0 ? { excludeIds: excluded.map((e) => e.id) } : {}
+    });
+    if (!item) {
+      info(
+        excluded.length > 0 ? "No ready work items (excluding the skipped ones \u2014 `motir next --reset` to retry them)." : "No ready work items."
+      );
+      return;
+    }
+    await ensureInProgress(client, item.key, item.status?.key);
+    const dispatch = await client.dispatchPrompt(item.key);
+    await deliver({
+      session,
+      key: item.key,
+      title: item.title,
+      id: item.id,
+      dispatch,
+      opts
+    });
+  });
+}
+function keyList(entries) {
+  return entries.map((e) => e.key).join(", ");
+}
+function notReadyError(detail) {
+  const reasons = detail.openBlockers.map((b) => `${b.identifier} (${b.title})`);
+  if (detail.blockedByAncestor) {
+    reasons.push(`its ancestor ${detail.blockedByAncestor.identifier} is blocked`);
+  }
+  const because = reasons.length > 0 ? ` Waiting on: ${reasons.join(", ")}.` : "";
+  return new CliError(`${detail.identifier} is not ready.${because}`, {
+    hint: `Pass --force to dispatch it anyway.`
+  });
+}
+async function runCommand(key, opts) {
+  const trimmed = key.trim();
+  if (!trimmed) throw new CliError("A work item key is required, e.g. `motir run PROD-7`.");
+  await withProjectSession(async (session) => {
+    const { client } = session;
+    const detail = await client.getWorkItem(trimmed);
+    const { item, readiness } = detail;
+    if (!readiness.ready && !opts.force) {
+      throw notReadyError({
+        identifier: item.identifier,
+        openBlockers: readiness.openBlockers,
+        blockedByAncestor: readiness.blockedByAncestor
+      });
+    }
+    if (!readiness.ready) {
+      info(`${item.identifier} is not ready \u2014 dispatching anyway (--force).`);
+    }
+    await ensureInProgress(client, item.identifier, item.status);
+    const dispatch = await client.dispatchPrompt(item.identifier);
+    await deliver({
+      session,
+      key: item.identifier,
+      title: item.title,
+      id: item.id,
+      dispatch,
+      opts
+    });
+  });
+}
+async function doneCommand(key, opts) {
+  if (opts.session) {
+    if (key) {
+      throw new CliError("Pass either a work item key or --session <branch>, not both.");
+    }
+    await withProjectSession(async ({ client }) => {
+      const result = await client.completeSession({
+        sessionBranch: opts.session,
+        implementationHarness: HARNESS
+      });
+      info(renderSessionOutcomes(result.sessionBranch, result.results));
+    });
+    return;
+  }
+  const trimmed = (key ?? "").trim();
+  if (!trimmed) {
+    throw new CliError("A work item key is required, e.g. `motir done PROD-7`.", {
+      hint: "Or close out a merged session PR with `motir done --session <branch>`."
+    });
+  }
+  await withProjectSession(async ({ client, serverUrl, projectKey }) => {
+    if (opts.via) {
+      await client.transitionStatus({ key: trimmed, status: opts.via });
+      info(`${trimmed}: \u2192 ${opts.via}`);
+    }
+    try {
+      await client.transitionStatus({ key: trimmed, status: DONE });
+    } catch (err) {
+      if (err instanceof CliError && !opts.via) {
+        throw new CliError(err.message, {
+          hint: `If the PR is merged but the item never reached In Review, try \`motir done --via ${IN_REVIEW} ${trimmed}\`.`
+        });
+      }
+      throw err;
+    }
+    removeExcludeByKey(serverUrl, projectKey, trimmed);
+    info(`${trimmed}: done.`);
+  });
+}
+
+// src/autoLoop.ts
+var CONTAINER_KINDS = /* @__PURE__ */ new Set(["epic", "story"]);
+function classifyReadyItem(item) {
+  if (CONTAINER_KINDS.has(item.kind.toLowerCase())) return "needs_planning";
+  if (item.executor === "human" || item.type === "manual") return "needs_human";
+  return "dispatch";
+}
+function planReviewUrl(serverUrl, planId) {
+  try {
+    return new URL(`/plans/${encodeURIComponent(planId)}`, serverUrl).toString();
+  } catch {
+    return null;
+  }
+}
+function formatDuration(ms) {
+  const total = Math.max(0, Math.round(ms / 1e3));
+  const minutes = Math.floor(total / 60);
+  const seconds = total % 60;
+  return minutes > 0 ? `${minutes}m ${String(seconds).padStart(2, "0")}s` : `${seconds}s`;
+}
+var OUTCOME_LABEL = {
+  integrated: "integrated",
+  in_review: "in review",
+  failed: "FAILED"
+};
+var STOP_LABEL = {
+  drained: "the ready set is drained",
+  max: "--max reached",
+  halted: "halted on the first agent failure (--keep-going continues past one)",
+  interrupted: "interrupted (Ctrl-C)"
+};
+var SKIP_LABEL = {
+  needs_planning: "needs planning",
+  needs_human: "needs a human"
+};
+function sessionPrTitle(runId, itemCount) {
+  return `Motir auto run ${runId} \u2014 ${itemCount} work item${itemCount === 1 ? "" : "s"}`;
+}
+function renderSessionPrBody(runId, branch, records) {
+  const carried = records.filter((r) => r.outcome !== "failed");
+  const failed = records.filter((r) => r.outcome === "failed");
+  const lines = [
+    `Unattended \`motir auto\` run \`${runId}\`, integrated on \`${branch}\`.`,
+    "",
+    `## Work items carried (${carried.length})`,
+    "",
+    ...carried.map((r) => `- ${r.key} \u2014 ${r.title ?? "(untitled)"}`)
+  ];
+  if (failed.length > 0) {
+    lines.push(
+      "",
+      `## Attempted and failed (${failed.length}) \u2014 still In Progress, not in this branch`,
+      "",
+      ...failed.map((r) => `- ${r.key} \u2014 ${r.title ?? "(untitled)"}`)
+    );
+  }
+  lines.push(
+    "",
+    "## Close-out",
+    "",
+    "Review this pull request as ONE unit. After merging it, run:",
+    "",
+    "```",
+    `motir done --session ${branch}`,
+    "```",
+    "",
+    "That flips every item recorded on the branch to Done and clears the recorded",
+    "branch. If the pull request is rejected instead, the items honestly stay In",
+    "Review \u2014 flip them back or re-dispatch them."
+  );
+  return lines.join("\n");
+}
+var SUMMARY_HEADERS = ["ITEM", "OUTCOME", "TIME", "BRANCH", "TITLE"];
+function renderAutoSummary(summary, titleWidth = 44) {
+  const blocks = [];
+  blocks.push(`Run ${summary.runId} \u2014 stopped: ${STOP_LABEL[summary.stopReason]}.`);
+  if (summary.records.length === 0) {
+    blocks.push("No work items were dispatched.");
+  } else {
+    const rows = summary.records.map((r) => [
+      r.key,
+      OUTCOME_LABEL[r.outcome] + (r.detail ? ` (${r.detail})` : ""),
+      formatDuration(r.durationMs),
+      r.sessionBranch ?? "\u2014",
+      truncate(r.title ?? "", titleWidth)
+    ]);
+    blocks.push(formatTable(SUMMARY_HEADERS, rows));
+  }
+  for (const reason of ["needs_planning", "needs_human"]) {
+    const group = summary.skipped.filter((s) => s.reason === reason);
+    if (group.length === 0) continue;
+    blocks.push(
+      [
+        `Skipped \u2014 ${SKIP_LABEL[reason]} (${group.length}):`,
+        ...group.map((s) => `  ${s.key} \u2014 ${truncate(s.title ?? "", titleWidth)}`)
+      ].join("\n")
+    );
+  }
+  blocks.push(...renderPlanningBlocks(summary.planning, titleWidth));
+  const inReview = summary.records.filter((r) => r.outcome !== "failed");
+  if (inReview.length > 0) {
+    blocks.push(
+      [
+        `In Review \u2014 awaiting your merge (${inReview.length}):`,
+        ...inReview.map((r) => `  ${r.key} on ${r.sessionBranch ?? "(no branch recorded)"}`)
+      ].join("\n")
+    );
+  }
+  const failed = summary.records.filter((r) => r.outcome === "failed");
+  if (failed.length > 0) {
+    blocks.push(
+      [
+        `Failed \u2014 still In Progress, nothing reverted (${failed.length}):`,
+        ...failed.map((r) => `  ${r.key} \u2014 re-run it with \`motir run ${r.key}\``)
+      ].join("\n")
+    );
+  }
+  if (summary.prs.length > 0) {
+    blocks.push(["Pull requests:", ...summary.prs.map(prLine)].join("\n"));
+  }
+  return blocks.join("\n\n");
+}
+function renderPlanningBlocks(planning, titleWidth) {
+  const blocks = [];
+  const triggered = planning.filter((p) => p.outcome === "triggered");
+  const failed = planning.filter((p) => p.outcome === "failed");
+  if (triggered.length > 0) {
+    blocks.push(
+      [
+        `Planning triggered \u2014 awaiting your approval (${triggered.length}):`,
+        ...triggered.map(
+          (p) => `  ${p.key} \u2014 ${truncate(p.title ?? "", titleWidth)}
+    plan ${p.planId ?? "(id not returned)"}${p.reviewUrl ? ` \u2014 ${p.reviewUrl}` : ""}`
+        ),
+        "  These are PROPOSALS. Nothing was added to the plan: approve them in Motir",
+        "  and their subtasks join a later run like any other ready work."
+      ].join("\n")
+    );
+  }
+  if (failed.length > 0) {
+    blocks.push(
+      [
+        `Planning failed \u2014 still unexpanded (${failed.length}):`,
+        ...failed.map((p) => `  ${p.key} \u2014 ${p.detail ?? "the expansion was refused"}`)
+      ].join("\n")
+    );
+  }
+  return blocks;
+}
+function prLine(pr) {
+  const repo = pr.repoName ?? "the checkout";
+  switch (pr.outcome) {
+    case "opened":
+      return `  ${repo}: ${pr.url ?? pr.branch} (opened)`;
+    case "existing":
+      return `  ${repo}: ${pr.url ?? pr.branch} (already open \u2014 updated by this run)`;
+    case "empty":
+      return `  ${repo}: no pull request \u2014 ${pr.branch} carries no commits beyond main.`;
+    case "failed":
+      return `  ${repo}: NOT opened. ${pr.message ?? ""}
+    The work IS pushed to ${pr.branch} \u2014 open the pull request by hand, then \`motir done --session ${pr.branch}\`.`;
+  }
+}
+function autoExitCode(summary) {
+  if (summary.records.some((r) => r.outcome === "failed")) return 1;
+  if (summary.stopReason === "interrupted") return 130;
+  return 0;
+}
+
+// src/git.ts
+import { spawnSync } from "child_process";
+var execCommand = (bin, args, cwd) => {
+  const res = spawnSync(bin, args, { cwd, encoding: "utf8", shell: false });
+  if (res.error) {
+    return { exitCode: 127, stdout: "", stderr: res.error.message };
+  }
+  return {
+    exitCode: res.status ?? 1,
+    stdout: (res.stdout ?? "").trim(),
+    stderr: (res.stderr ?? "").trim()
+  };
+};
+function sessionBranchName(runId) {
+  return `motir/auto-${runId}`;
+}
+function runIdFromDate(now) {
+  const pad = (n, width = 2) => String(n).padStart(width, "0");
+  return `${now.getFullYear()}${pad(now.getMonth() + 1)}${pad(now.getDate())}-${pad(now.getHours())}${pad(now.getMinutes())}${pad(now.getSeconds())}`;
+}
+var GitError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "GitError";
+  }
+};
+function requireOk(res, what) {
+  if (res.exitCode !== 0) {
+    throw new GitError(`${what} failed: ${res.stderr || res.stdout || `exit ${res.exitCode}`}`);
+  }
+  return res;
+}
+function ensureSessionBranchOnOrigin(cwd, branch, run = execCommand) {
+  requireOk(run("git", ["fetch", "origin"], cwd), "git fetch origin");
+  const exists = run(
+    "git",
+    ["rev-parse", "--verify", "--quiet", `refs/remotes/origin/${branch}`],
+    cwd
+  );
+  if (exists.exitCode === 0) return "already_on_origin";
+  requireOk(
+    run("git", ["push", "origin", `refs/remotes/origin/main:refs/heads/${branch}`], cwd),
+    `creating ${branch} on origin`
+  );
+  return "created";
+}
+function pushSessionBranchIfAhead(cwd, branch, run = execCommand) {
+  const local = run("git", ["rev-parse", "--verify", "--quiet", `refs/heads/${branch}`], cwd);
+  if (local.exitCode !== 0) return "no_local_branch";
+  const ahead = run("git", ["rev-list", "--count", `origin/${branch}..${branch}`], cwd);
+  if (ahead.exitCode === 0 && ahead.stdout.trim() === "0") return "up_to_date";
+  requireOk(run("git", ["push", "origin", branch], cwd), `pushing ${branch}`);
+  return "pushed";
+}
+function sessionBranchHasCommits(cwd, branch, run = execCommand) {
+  const res = run("git", ["rev-list", "--count", `origin/main..origin/${branch}`], cwd);
+  if (res.exitCode !== 0) return false;
+  return Number.parseInt(res.stdout.trim(), 10) > 0;
+}
+function openSessionPr(cwd, input, run = execCommand) {
+  const existing = run(
+    "gh",
+    ["pr", "list", "--head", input.branch, "--state", "open", "--json", "url", "--jq", ".[0].url"],
+    cwd
+  );
+  if (existing.exitCode === 0 && existing.stdout.trim()) {
+    return { url: existing.stdout.trim(), outcome: "existing" };
+  }
+  const created = run(
+    "gh",
+    [
+      "pr",
+      "create",
+      "--base",
+      "main",
+      "--head",
+      input.branch,
+      "--title",
+      input.title,
+      "--body",
+      input.body
+    ],
+    cwd
+  );
+  if (created.exitCode !== 0) {
+    return {
+      url: null,
+      outcome: "failed",
+      message: `Could not open the pull request for ${input.branch}: ${created.stderr || created.stdout || `gh exited ${created.exitCode}`}`
+    };
+  }
+  const url = created.stdout.split("\n").filter(Boolean).pop() ?? null;
+  return { url, outcome: "opened" };
+}
+
+// src/commands/auto.ts
+var HARNESS2 = `motir-cli/${CLI_VERSION}`;
+function parseMax(raw) {
+  if (raw === void 0) return null;
+  const n = Number.parseInt(raw, 10);
+  if (!Number.isFinite(n) || n <= 0 || String(n) !== raw.trim()) {
+    throw new CliError(`--max must be a positive whole number, got "${raw}".`);
+  }
+  return n;
+}
+function requireAgent(opts) {
+  if (opts.print) {
+    throw new CliError("`motir auto` cannot run in --print mode.", {
+      hint: "An unattended loop has nobody to paste a prompt. Use `motir next --print` for one item, or pass --agent <cmd>."
+    });
+  }
+  const agent = resolveAgent(opts);
+  if (!agent) {
+    throw new CliError("`motir auto` needs an agent to run.", {
+      hint: 'Pass --agent "<cmd>", set MOTIR_AGENT, or configure agentCommand. `motir doctor` checks it.'
+    });
+  }
+  return agent;
+}
+var RepoSessions = class {
+  constructor(branch, run) {
+    this.branch = branch;
+    this.run = run;
+  }
+  branch;
+  run;
+  byPath = /* @__PURE__ */ new Map();
+  ensure(target) {
+    const existing = this.byPath.get(target.cwd);
+    if (existing !== void 0) return existing;
+    if (target.reason !== "repo_checkout") {
+      const session2 = this.tryCreate(target, { tolerateFailure: true });
+      this.byPath.set(target.cwd, session2);
+      return session2;
+    }
+    const session = this.tryCreate(target, { tolerateFailure: false });
+    this.byPath.set(target.cwd, session);
+    return session;
+  }
+  tryCreate(target, opts) {
+    try {
+      const outcome = ensureSessionBranchOnOrigin(target.cwd, this.branch, this.run);
+      info(
+        outcome === "created" ? `Session branch ${this.branch} created on origin in ${target.cwd}.` : `Session branch ${this.branch} already on origin in ${target.cwd} \u2014 reusing it.`
+      );
+      return { repoName: target.targetRepo, cwd: target.cwd, branch: this.branch, keys: [] };
+    } catch (err) {
+      if (!opts.tolerateFailure) throw err;
+      info(
+        `No session branch in ${target.cwd} (${err instanceof Error ? err.message : String(err)}). Items routed here ship as their own pull request.`
+      );
+      return null;
+    }
+  }
+  /** Every repo a session branch was opened in, in first-touch order. A repo
+   *  whose only item failed is included on purpose: its branch EXISTS on origin,
+   *  and the summary saying so beats leaving a stray branch unmentioned. */
+  touched() {
+    return [...this.byPath.values()].filter((s) => s !== null);
+  }
+};
+async function autoCommand(opts, deps = {}) {
+  const run = deps.run ?? execCommand;
+  const clock = deps.clock ?? Date.now;
+  const kinds = parseKinds(opts.kinds);
+  const max = parseMax(opts.max);
+  const agent = requireAgent(opts);
+  const runId = runIdFromDate((deps.now ?? (() => /* @__PURE__ */ new Date()))());
+  const branch = sessionBranchName(runId);
+  await withProjectSession(async (session) => {
+    const summary = await runAutoLoop({
+      session,
+      opts,
+      kinds,
+      max,
+      agent,
+      runId,
+      branch,
+      run,
+      clock,
+      runAgentFn: deps.runAgentFn ?? runAgent
+    });
+    closeOutRepos(summary, run);
+    info("");
+    info(renderAutoSummary(summary));
+    process.exitCode = autoExitCode(summary);
+  });
+}
+async function runAutoLoop(input) {
+  const { session, opts, kinds, max, agent, runId, branch, run, clock, runAgentFn } = input;
+  const { client, serverUrl, projectKey } = session;
+  if (opts.reset) {
+    const cleared = clearExcludes(serverUrl, projectKey);
+    info(`Cleared ${cleared} excluded item${cleared === 1 ? "" : "s"}.`);
+  }
+  const excludeIds = new Set(readExcludes(serverUrl, projectKey).map((e) => e.id));
+  const records = [];
+  const skipped = [];
+  const planning = [];
+  const repos = new RepoSessions(branch, run);
+  let interrupted = false;
+  const onSigint = () => {
+    if (interrupted) process.exit(130);
+    interrupted = true;
+    info("");
+    info("Interrupt received \u2014 finishing up and opening the session pull request(s).");
+    info("Press Ctrl-C again to exit immediately.");
+  };
+  process.on("SIGINT", onSigint);
+  let stopReason = "drained";
+  try {
+    for (; ; ) {
+      if (interrupted) {
+        stopReason = "interrupted";
+        break;
+      }
+      if (max !== null && records.length >= max) {
+        stopReason = "max";
+        break;
+      }
+      const { item } = await client.nextReady({
+        projectKey,
+        ...kinds ? { kinds } : {},
+        ...excludeIds.size > 0 ? { excludeIds: [...excludeIds] } : {}
+      });
+      if (!item) {
+        stopReason = "drained";
+        break;
+      }
+      const disposition = classifyReadyItem(item);
+      if (disposition === "needs_planning" && opts.includePlanning) {
+        planning.push(await triggerExpansion(client, serverUrl, item));
+        excludeIds.add(item.id);
+        continue;
+      }
+      if (disposition !== "dispatch") {
+        skipped.push({ key: item.key, title: item.title, reason: disposition });
+        excludeIds.add(item.id);
+        info(
+          `${item.key}: skipped \u2014 ${disposition === "needs_planning" ? "an unexpanded container needs planning" : "human work"}.`
+        );
+        continue;
+      }
+      const target = resolveDispatchTarget(session.link.dir, session.link.config, item.targetRepo);
+      let repo;
+      try {
+        repo = repos.ensure(target);
+      } catch (err) {
+        info("");
+        info(`${item.key}: ${err instanceof GitError ? err.message : String(err)}`);
+        stopReason = "halted";
+        break;
+      }
+      const record = await dispatchOne({
+        client,
+        item,
+        target,
+        repo,
+        agent,
+        clock,
+        runAgentFn,
+        onIntegrated: (key) => repo?.keys.push(key)
+      });
+      records.push(record);
+      if (record.outcome === "failed") {
+        addExclude(serverUrl, projectKey, { id: item.id, key: item.key });
+        excludeIds.add(item.id);
+        if (!opts.keepGoing) {
+          stopReason = interrupted ? "interrupted" : "halted";
+          break;
+        }
+      } else {
+        removeExclude(serverUrl, projectKey, item.id);
+      }
+    }
+  } finally {
+    process.off("SIGINT", onSigint);
+  }
+  return { runId, records, skipped, planning, repos: repos.touched(), prs: [], stopReason };
+}
+async function triggerExpansion(client, serverUrl, item) {
+  const base = { key: item.key, title: item.title };
+  try {
+    const { planId, jobId } = await client.expandItem(item.key);
+    const reviewUrl = planReviewUrl(serverUrl, planId);
+    info(
+      `${item.key}: planning triggered \u2014 job ${jobId}, plan ${planId}. It produces PROPOSALS awaiting your approval; the loop moves on.`
+    );
+    return { ...base, outcome: "triggered", planId, reviewUrl };
+  } catch (err) {
+    const detail = err instanceof Error ? err.message : String(err);
+    info(`${item.key}: planning FAILED \u2014 ${detail}. Left unexpanded; the loop continues.`);
+    return { ...base, outcome: "failed", planId: null, reviewUrl: null, detail };
+  }
+}
+async function dispatchOne(input) {
+  const { client, item, target, repo, agent, clock, runAgentFn, onIntegrated } = input;
+  await ensureInProgress(client, item.key, item.status?.key);
+  const dispatch = await client.dispatchPrompt(item.key, { sessionBranch: repo?.branch ?? null });
+  info("");
+  info(`\u2500\u2500 ${item.key} \u2014 ${item.title}`);
+  info(`   ${target.cwd}  (${cwdReasonLabel(target)})`);
+  info(
+    dispatch.sessionBranch ? `   integrating into ${dispatch.sessionBranch}` : "   no session lineage \u2014 this item ships as its own pull request"
+  );
+  const started = clock();
+  const result = await runAgentFn({
+    command: agent.parsed,
+    prompt: dispatch.prompt,
+    cwd: target.cwd
+  });
+  const durationMs = clock() - started;
+  const base = {
+    key: item.key,
+    title: item.title,
+    durationMs,
+    repo: dispatch.targetRepo
+  };
+  if (result.exitCode !== 0) {
+    info(`${item.key}: agent exited ${result.exitCode} \u2014 left In Progress, nothing reverted.`);
+    return {
+      ...base,
+      outcome: "failed",
+      sessionBranch: null,
+      detail: result.signal ? `killed by ${result.signal}` : `exit ${result.exitCode}`
+    };
+  }
+  const suspect = checkBootstrapCheckout(target);
+  if (suspect) {
+    info(`${item.key}: ${suspect.message}`);
+    info(`Hint: ${suspect.hint}`);
+    return {
+      ...base,
+      outcome: "failed",
+      sessionBranch: null,
+      detail: "bootstrap checkout missing"
+    };
+  }
+  if (dispatch.workflowMode === "session_lineage" && dispatch.sessionBranch) {
+    await client.markIntegrated({
+      key: item.key,
+      sessionBranch: dispatch.sessionBranch,
+      implementationHarness: HARNESS2
+    });
+    onIntegrated(item.key);
+    info(`${item.key}: integrated on ${dispatch.sessionBranch} in ${formatDuration(durationMs)}.`);
+    return { ...base, outcome: "integrated", sessionBranch: dispatch.sessionBranch };
+  }
+  await client.transitionStatus({ key: item.key, status: "in_review" });
+  info(`${item.key}: In Review via its own pull request in ${formatDuration(durationMs)}.`);
+  return { ...base, outcome: "in_review", sessionBranch: null, detail: "own pull request" };
+}
+function closeOutRepos(summary, run) {
+  for (const repo of summary.repos) {
+    const report = closeOutRepo(summary, repo, run);
+    summary.prs.push(report);
+  }
+}
+function closeOutRepo(summary, repo, run) {
+  const base = { repoName: repo.repoName, branch: repo.branch };
+  try {
+    const pushed = pushSessionBranchIfAhead(repo.cwd, repo.branch, run);
+    if (pushed === "pushed") info(`Pushed ${repo.branch} in ${repo.cwd}.`);
+    if (!sessionBranchHasCommits(repo.cwd, repo.branch, run)) {
+      return { ...base, url: null, outcome: "empty" };
+    }
+    const mine = summary.records.filter(
+      (r) => r.sessionBranch === repo.branch || r.outcome === "failed" && r.repo === repo.repoName
+    );
+    const carried = mine.filter((r) => r.outcome !== "failed");
+    const result = openSessionPr(
+      repo.cwd,
+      {
+        branch: repo.branch,
+        title: sessionPrTitle(summary.runId, carried.length),
+        body: renderSessionPrBody(summary.runId, repo.branch, mine)
+      },
+      run
+    );
+    return {
+      ...base,
+      url: result.url,
+      outcome: result.outcome,
+      ...result.message ? { message: result.message } : {}
+    };
+  } catch (err) {
+    return {
+      ...base,
+      url: null,
+      outcome: "failed",
+      message: err instanceof Error ? err.message : String(err)
+    };
+  }
+}
+
+// src/batchPlan.ts
+function classifySnapshotItem(item) {
+  const shared = classifyReadyItem(item);
+  if (shared !== "dispatch") return shared;
+  if (item.sessionBranch) return "integrated_dep";
+  return "take";
+}
+var OUTCOME_LABEL2 = {
+  in_review: "in review",
+  failed: "FAILED"
+};
+var STOP_LABEL2 = {
+  completed: "the whole snapshot was attempted",
+  max: "--max reached",
+  halted: "halted on the first agent failure (--keep-going continues past one)",
+  interrupted: "interrupted (Ctrl-C)"
+};
+var SKIP_LABEL2 = {
+  needs_planning: "needs planning",
+  needs_human: "needs a human",
+  integrated_dep: "ready only via an integrated dependency (not on main)"
+};
+var SKIP_ORDER = ["needs_planning", "needs_human", "integrated_dep"];
+var PLAN_HEADERS = ["ITEM", "KIND", "REPO", "TITLE"];
+function renderSnapshotPlan(snapshot, titleWidth = 44) {
+  const blocks = [];
+  const { taken, skipped } = snapshot;
+  if (taken.length === 0) {
+    blocks.push("Snapshot: no work items to implement.");
+  } else {
+    blocks.push(
+      `Snapshot: ${taken.length} work item${taken.length === 1 ? "" : "s"} \u2014 this exact list, one at a time. Items that become ready during the run are NOT picked up.`
+    );
+    blocks.push(
+      formatTable(
+        PLAN_HEADERS,
+        taken.map((e) => [e.key, e.kind, e.targetRepo ?? "\u2014", truncate(e.title ?? "", titleWidth)])
+      )
+    );
+  }
+  blocks.push(...renderSkipGroups(skipped, titleWidth));
+  return blocks.join("\n\n");
+}
+function renderSkipGroups(skipped, titleWidth) {
+  const blocks = [];
+  for (const reason of SKIP_ORDER) {
+    const group = skipped.filter((s) => s.reason === reason);
+    if (group.length === 0) continue;
+    const lines = [
+      `Not in the snapshot \u2014 ${SKIP_LABEL2[reason]} (${group.length}):`,
+      ...group.map((s) => `  ${s.key} \u2014 ${truncate(s.title ?? "", titleWidth)}`)
+    ];
+    if (reason === "integrated_dep") {
+      lines.push("  Run these with `motir auto`, which carries that lineage on a session branch.");
+    }
+    blocks.push(lines.join("\n"));
+  }
+  return blocks;
+}
+var SUMMARY_HEADERS2 = ["ITEM", "OUTCOME", "TIME", "REPO", "TITLE"];
+function renderBatchSummary(summary, titleWidth = 44) {
+  const blocks = [];
+  blocks.push(`Batch finished \u2014 stopped: ${STOP_LABEL2[summary.stopReason]}.`);
+  if (summary.records.length === 0) {
+    blocks.push("No work items were dispatched.");
+  } else {
+    blocks.push(
+      formatTable(
+        SUMMARY_HEADERS2,
+        summary.records.map((r) => [
+          r.key,
+          OUTCOME_LABEL2[r.outcome] + (r.detail ? ` (${r.detail})` : ""),
+          formatDuration(r.durationMs),
+          r.repo ?? "\u2014",
+          truncate(r.title ?? "", titleWidth)
+        ])
+      )
+    );
+  }
+  const inReview = summary.records.filter((r) => r.outcome === "in_review");
+  if (inReview.length > 0) {
+    blocks.push(
+      [
+        `In Review \u2014 each has its OWN pull request to merge (${inReview.length}):`,
+        ...inReview.map((r) => `  ${r.key} \u2014 review + merge it, then \`motir done ${r.key}\``)
+      ].join("\n")
+    );
+  }
+  const failed = summary.records.filter((r) => r.outcome === "failed");
+  if (failed.length > 0) {
+    blocks.push(
+      [
+        `Failed \u2014 still In Progress, nothing reverted (${failed.length}):`,
+        ...failed.map((r) => `  ${r.key} \u2014 re-run it with \`motir run ${r.key}\``)
+      ].join("\n")
+    );
+  }
+  if (summary.notReached.length > 0) {
+    blocks.push(
+      [
+        `Not reached \u2014 still in the snapshot, never started (${summary.notReached.length}):`,
+        ...summary.notReached.map((e) => `  ${e.key} \u2014 ${truncate(e.title ?? "", titleWidth)}`),
+        "  Re-run `motir batch` to take a fresh snapshot including these."
+      ].join("\n")
+    );
+  }
+  blocks.push(...renderSkipGroups(summary.skipped, titleWidth));
+  if (summary.newlyReady.length > 0) {
+    blocks.push(
+      [
+        `${summary.newlyReady.length} became ready during the run \u2014 NOT dispatched (a snapshot is frozen on purpose):`,
+        ...summary.newlyReady.map((n) => `  ${n.key} \u2014 ${truncate(n.title ?? "", titleWidth)}`),
+        "  Re-run `motir batch`, or use `motir auto` to follow the ready set live."
+      ].join("\n")
+    );
+  }
+  return blocks.join("\n\n");
+}
+function batchExitCode(summary) {
+  if (summary.records.some((r) => r.outcome === "failed")) return 1;
+  if (summary.stopReason === "interrupted") return 130;
+  return 0;
+}
+
+// src/commands/batch.ts
+function requireAgent2(opts) {
+  if (opts.print) {
+    throw new CliError("`motir batch` cannot run in --print mode.", {
+      hint: "A batch has nobody to paste a prompt. Use `motir next --print` for one item, or pass --agent <cmd>."
+    });
+  }
+  const agent = resolveAgent(opts);
+  if (!agent) {
+    throw new CliError("`motir batch` needs an agent to run.", {
+      hint: 'Pass --agent "<cmd>", set MOTIR_AGENT, or configure agentCommand. `motir doctor` checks it.'
+    });
+  }
+  return agent;
+}
+async function enumerateReady(client, projectKey, kinds, seedExcludeIds) {
+  const seen = new Set(seedExcludeIds);
+  const items = [];
+  for (; ; ) {
+    const { item } = await client.nextReady({
+      projectKey,
+      ...kinds ? { kinds } : {},
+      ...seen.size > 0 ? { excludeIds: [...seen] } : {}
+    });
+    if (!item) return items;
+    if (seen.has(item.id)) return items;
+    seen.add(item.id);
+    items.push(item);
+  }
+}
+function planSnapshot(items) {
+  const taken = [];
+  const skipped = [];
+  for (const item of items) {
+    const disposition = classifySnapshotItem(item);
+    if (disposition === "take") {
+      taken.push({
+        id: item.id,
+        key: item.key,
+        title: item.title,
+        kind: item.kind,
+        targetRepo: item.targetRepo,
+        statusKey: item.status?.key
+      });
+    } else {
+      skipped.push({ key: item.key, title: item.title, reason: disposition });
+    }
+  }
+  return { taken, skipped };
+}
+async function batchCommand(opts, deps = {}) {
+  const kinds = parseKinds(opts.kinds);
+  const max = parseMax(opts.max);
+  const agent = requireAgent2(opts);
+  await withProjectSession(async (session) => {
+    const summary = await runBatch({
+      session,
+      opts,
+      kinds,
+      max,
+      agent,
+      clock: deps.clock ?? Date.now,
+      runAgentFn: deps.runAgentFn ?? runAgent
+    });
+    info("");
+    info(renderBatchSummary(summary));
+    process.exitCode = batchExitCode(summary);
+  });
+}
+async function runBatch(input) {
+  const { session, opts, kinds, max, agent, clock, runAgentFn } = input;
+  const { client, serverUrl, projectKey } = session;
+  if (opts.reset) {
+    const cleared = clearExcludes(serverUrl, projectKey);
+    info(`Cleared ${cleared} excluded item${cleared === 1 ? "" : "s"}.`);
+  }
+  const persistedExcludes = new Set(readExcludes(serverUrl, projectKey).map((e) => e.id));
+  if (persistedExcludes.size > 0) {
+    info(
+      `Skipping ${persistedExcludes.size} previously-failed item(s) \u2014 \`--reset\` retries them.`
+    );
+  }
+  const snapshot = planSnapshot(await enumerateReady(client, projectKey, kinds, persistedExcludes));
+  const snapshotIds = /* @__PURE__ */ new Set([...snapshot.taken.map((e) => e.id), ...persistedExcludes]);
+  const skippedIds = /* @__PURE__ */ new Set();
+  info(renderSnapshotPlan(snapshot));
+  const records = [];
+  const skipped = [...snapshot.skipped];
+  let stopIndex = snapshot.taken.length;
+  let stopReason = "completed";
+  let interrupted = false;
+  const onSigint = () => {
+    if (interrupted) process.exit(130);
+    interrupted = true;
+    info("");
+    info("Interrupt received \u2014 finishing the item in flight, then stopping.");
+    info("Press Ctrl-C again to exit immediately.");
+  };
+  process.on("SIGINT", onSigint);
+  try {
+    for (const [index, entry] of snapshot.taken.entries()) {
+      if (interrupted) {
+        stopReason = "interrupted";
+        stopIndex = index;
+        break;
+      }
+      if (max !== null && records.length >= max) {
+        stopReason = "max";
+        stopIndex = index;
+        break;
+      }
+      const outcome = await dispatchOne2({
+        session,
+        entry,
+        agent,
+        clock,
+        runAgentFn
+      });
+      if (outcome.kind === "skipped") {
+        skipped.push(outcome.skip);
+        skippedIds.add(entry.id);
+        continue;
+      }
+      records.push(outcome.record);
+      if (outcome.record.outcome === "failed") {
+        addExclude(serverUrl, projectKey, { id: entry.id, key: entry.key });
+        if (!opts.keepGoing) {
+          stopReason = interrupted ? "interrupted" : "halted";
+          stopIndex = index + 1;
+          break;
+        }
+      } else {
+        removeExclude(serverUrl, projectKey, entry.id);
+      }
+    }
+  } finally {
+    process.off("SIGINT", onSigint);
+  }
+  const notReached = snapshot.taken.slice(stopIndex).filter((e) => !skippedIds.has(e.id) && !records.some((r) => r.key === e.key));
+  return {
+    records,
+    skipped,
+    notReached,
+    // Reporting only — read AFTER the drain, and never fed back into it.
+    newlyReady: await countNewlyReady(client, projectKey, kinds, snapshotIds, snapshot.skipped),
+    stopReason
+  };
+}
+async function countNewlyReady(client, projectKey, kinds, snapshotIds, snapshotSkips) {
+  const skippedKeys = new Set(snapshotSkips.map((s) => s.key));
+  const after = await enumerateReady(client, projectKey, kinds, /* @__PURE__ */ new Set());
+  return after.filter((item) => !snapshotIds.has(item.id) && !skippedKeys.has(item.key)).map((item) => ({ key: item.key, title: item.title }));
+}
+async function dispatchOne2(input) {
+  const { session, entry, agent, clock, runAgentFn } = input;
+  const { client, link } = session;
+  const dispatch = await client.dispatchPrompt(entry.key);
+  if (dispatch.workflowMode === "session_lineage") {
+    info(
+      `${entry.key}: skipped \u2014 a dependency was integrated on ${dispatch.sessionBranch ?? "a session branch"} after the snapshot was taken.`
+    );
+    return {
+      kind: "skipped",
+      skip: { key: entry.key, title: entry.title, reason: "integrated_dep" }
+    };
+  }
+  await ensureInProgress(client, entry.key, entry.statusKey);
+  const target = resolveDispatchTarget(link.dir, link.config, dispatch.targetRepo);
+  info("");
+  info(`\u2500\u2500 ${entry.key} \u2014 ${entry.title ?? ""}`);
+  info(`   ${target.cwd}  (${cwdReasonLabel(target)})`);
+  info("   its own branch off origin/main, its own pull request");
+  const started = clock();
+  const result = await runAgentFn({
+    command: agent.parsed,
+    prompt: dispatch.prompt,
+    cwd: target.cwd
+  });
+  const durationMs = clock() - started;
+  const base = { key: entry.key, title: entry.title, durationMs, repo: dispatch.targetRepo };
+  if (result.exitCode !== 0) {
+    info(`${entry.key}: agent exited ${result.exitCode} \u2014 left In Progress, nothing reverted.`);
+    return {
+      kind: "record",
+      record: {
+        ...base,
+        outcome: "failed",
+        detail: result.signal ? `killed by ${result.signal}` : `exit ${result.exitCode}`
+      }
+    };
+  }
+  const suspect = checkBootstrapCheckout(target);
+  if (suspect) {
+    info(`${entry.key}: ${suspect.message}`);
+    info(`Hint: ${suspect.hint}`);
+    return {
+      kind: "record",
+      record: { ...base, outcome: "failed", detail: "bootstrap checkout missing" }
+    };
+  }
+  await client.transitionStatus({ key: entry.key, status: "in_review" });
+  info(`${entry.key}: In Review via its own pull request.`);
+  return { kind: "record", record: { ...base, outcome: "in_review" } };
+}
+
+// src/plan.ts
+var WORK_ITEM_KEY = /^[A-Za-z][A-Za-z0-9]*-\d+$/;
+var WATCH_TIMEOUT_MS = 10 * 60 * 1e3;
+var WATCH_POLL_MS = 3e3;
+var PROPOSALS_NOT_WORK_ITEMS = "These are PROPOSALS, not work items. Nothing above exists in the tree yet \u2014 approving the plan in Motir is the only thing that creates one.";
+function parsePlanArgs(args) {
+  const targetKeys = [];
+  let index = 0;
+  while (index < args.length && WORK_ITEM_KEY.test(args[index].trim())) {
+    const key = args[index].trim().toUpperCase();
+    if (!targetKeys.includes(key)) targetKeys.push(key);
+    index += 1;
+  }
+  const text = args.slice(index).join(" ").trim();
+  return { targetKeys, text: text.length > 0 ? text : null };
+}
+function classifyInput(line) {
+  if (line === null) return { kind: "exit" };
+  const trimmed = line.trim();
+  if (trimmed.length === 0) return { kind: "none" };
+  if (!trimmed.startsWith("/")) return { kind: "turn", body: trimmed };
+  const word = trimmed.slice(1).toLowerCase();
+  if (word === "submit" || word === "send") return { kind: "submit" };
+  if (word === "exit" || word === "quit") return { kind: "exit" };
+  if (word === "help" || word === "?") return { kind: "help" };
+  return { kind: "unknown", input: trimmed };
+}
+function loopCommands() {
+  return [
+    "  Type what you want changed about the plan; press Enter to add it as a turn.",
+    "  Turns ACCUMULATE \u2014 nothing reaches the planner until you submit.",
+    "",
+    "  /submit   send every turn on this thread as ONE change",
+    "  /exit     leave; the thread and its turns stay saved",
+    "  /help     this list"
+  ].join("\n");
+}
+function onboardingUrl(serverUrl) {
+  return `${normalizeServerUrl(serverUrl)}/onboarding`;
+}
+function scopeLabel(targetKeys) {
+  return targetKeys.length > 0 ? `anchored at ${targetKeys.join(", ")}` : "project-wide";
+}
+function renderTurn(turn, ordinal) {
+  const marker = turn.role === "system" ? `submitted \u2192 job ${turn.jobId ?? "?"}` : "you";
+  const head = `  ${String(ordinal).padStart(2)}. [${marker}] `;
+  const indent = " ".repeat(head.length);
+  const [first = "", ...rest] = turn.body.split("\n");
+  return [head + first, ...rest.map((line) => indent + line)].join("\n");
+}
+function renderThread(session) {
+  const resumed = session.turnCount > 0;
+  const lines = [
+    `${resumed ? "Resumed" : "Opened"} the planning conversation (${scopeLabel(
+      session.targetKeys
+    )}) \u2014 ${session.turnCount} turn${session.turnCount === 1 ? "" : "s"}.`,
+    session.lastSubmittedAt ? `Last submitted ${session.lastSubmittedAt}${session.lastJobId ? ` as job ${session.lastJobId}` : ""}.` : "Never submitted \u2014 nothing has been sent to the planner yet."
+  ];
+  if (session.turns.length > 0) {
+    lines.push("", ...session.turns.map((turn, i) => renderTurn(turn, i + 1)));
+  }
+  return lines.join("\n");
+}
+function watchVerdict(outcome) {
+  if (outcome.status !== "generating") return { kind: "ready" };
+  const job = outcome.job;
+  if (!job) return { kind: "pending" };
+  if (!job.reachable) {
+    return {
+      kind: "failed",
+      reachable: false,
+      code: job.failure?.code ?? "AI_UNREACHABLE",
+      message: job.failure?.message ?? "motir-ai could not be reached."
+    };
+  }
+  if (job.status === "failed" || job.status === "canceled") {
+    return {
+      kind: "failed",
+      reachable: true,
+      code: job.failure?.code ?? `JOB_${job.status.toUpperCase()}`,
+      message: job.failure?.message ?? `The planning job ${job.status}.`
+    };
+  }
+  return { kind: "pending" };
+}
+var TEMP_REF_PREFIX = "planItem:";
+var OP_MARKER = { add: "+", modify: "~", remove: "-" };
+function sizing(points, minutes) {
+  const parts = [];
+  if (points != null) parts.push(`${points} pts`);
+  if (minutes != null) parts.push(`${minutes}m`);
+  return parts.length > 0 ? ` (${parts.join(" \xB7 ")})` : "";
+}
+function blockers(refs) {
+  return refs && refs.length > 0 ? ` \xB7 blocked_by: ${refs.join(", ")}` : "";
+}
+function describeProposal(item) {
+  const marker = OP_MARKER[item.op] ?? "?";
+  if (item.op === "add") {
+    const fields = item.proposedFields;
+    const kind = fields?.kind ?? "task";
+    const type = fields?.type ? `/${fields.type}` : "";
+    return `${marker} [${kind}${type}] ${fields?.title ?? "(untitled)"}` + sizing(fields?.storyPoints, fields?.estimateMinutes) + blockers(item.blockedByRefs);
+  }
+  const target = item.workItemId ?? "(no target)";
+  if (item.op === "remove") return `${marker} remove ${target}`;
+  const changed = Object.keys(item.patch ?? {}).filter(
+    (key) => item.patch[key] !== void 0
+  );
+  return `${marker} modify ${target}` + (changed.length > 0 ? ` \u2014 ${changed.join(", ")}` : "") + blockers(item.blockedByRefs);
+}
+function renderProposalTree(items) {
+  const byId = new Map(items.map((item) => [item.id, item]));
+  const childrenOf = /* @__PURE__ */ new Map();
+  const roots = [];
+  for (const item of items) {
+    const ref = item.parentRef;
+    const parentId = ref && ref.startsWith(TEMP_REF_PREFIX) ? ref.slice(TEMP_REF_PREFIX.length) : null;
+    if (parentId != null && byId.has(parentId)) {
+      const siblings = childrenOf.get(parentId);
+      if (siblings) siblings.push(item);
+      else childrenOf.set(parentId, [item]);
+    } else {
+      roots.push(item);
+    }
+  }
+  const lines = [];
+  const seen = /* @__PURE__ */ new Set();
+  const walk = (item, depth) => {
+    if (seen.has(item.id)) return;
+    seen.add(item.id);
+    lines.push(`${"  ".repeat(depth + 1)}${describeProposal(item)}`);
+    for (const child of childrenOf.get(item.id) ?? []) walk(child, depth + 1);
+  };
+  for (const root of roots) walk(root, 0);
+  for (const item of items) walk(item, 0);
+  return lines;
+}
+function renderPlan(plan) {
+  const lines = [
+    `Plan ${plan.id} \u2014 ${plan.status}, ${plan.itemCount} proposal${plan.itemCount === 1 ? "" : "s"}.`
+  ];
+  if (plan.title) lines.push(`Title: ${plan.title}`);
+  if (plan.summary) lines.push(`Summary: ${plan.summary}`);
+  lines.push("");
+  if (plan.items.length === 0) {
+    lines.push(
+      plan.status === "generating" ? "No proposals have arrived yet \u2014 the planner is still generating this plan." : "This plan bundles no proposals."
+    );
+  } else {
+    lines.push(
+      "Proposals (indented under their proposed parent):",
+      ...renderProposalTree(plan.items)
+    );
+  }
+  lines.push("", PROPOSALS_NOT_WORK_ITEMS);
+  return lines.join("\n");
+}
+function nextStepHint(reviewUrl, anchored) {
+  const resume = anchored.length > 0 ? `motir plan ${anchored.join(" ")}` : "motir plan";
+  return [
+    "Next:",
+    `  \u2022 refine  \u2014 \`${resume}\` adds another turn to the same conversation`,
+    `  \u2022 approve \u2014 ${reviewUrl ?? "open the plan in Motir"}`
+  ].join("\n");
+}
+
+// src/commands/plan.ts
+function delay(ms) {
+  return new Promise((resolve3) => {
+    setTimeout(resolve3, ms);
+  });
+}
+async function planCommand(args = [], opts = {}, deps = {}) {
+  const { targetKeys, text } = parsePlanArgs(args);
+  const readLine = deps.readLine ?? promptLineOrNull;
+  const interactive = deps.interactive ?? isInteractive;
+  if (!text && !interactive()) {
+    throw new CliError("`motir plan` needs a terminal to converse in.", {
+      hint: 'Non-interactively, pass the turn as text: `motir plan "<what to change>"` (add --detach to skip the wait).'
+    });
+  }
+  await withProjectSession(async (session) => {
+    await requirePlannedProject(session);
+    const scope = {
+      projectKey: session.projectKey,
+      ...targetKeys.length > 0 ? { targetKeys } : {}
+    };
+    const submitted = text ? await submitOneShot(session.client, scope, text) : await converse(session.client, scope, readLine);
+    if (!submitted) return;
+    info(
+      `Submitted this conversation's accumulated intent (${scopeLabel(targetKeys)}) \u2014 job ${submitted.jobId} \xB7 plan ${submitted.planId}.`
+    );
+    const reviewUrl = planReviewUrl(session.serverUrl, submitted.planId);
+    if (opts.detach) {
+      reportDetached(submitted, reviewUrl, targetKeys);
+      return;
+    }
+    await watchAndShow(session.client, submitted.planId, reviewUrl, targetKeys, deps);
+  });
+}
+async function requirePlannedProject(session) {
+  const page = await session.client.searchWorkItems({ projectKey: session.projectKey, limit: 1 });
+  if (page.total > 0) return;
+  throw new CliError(
+    `${session.projectKey} has no work items yet \u2014 there is no plan here to change.`,
+    {
+      hint: `Start it in Motir: ${onboardingUrl(session.serverUrl)} \u2014 the discovery interview is what GENERATES a first plan, and it is a guided web flow. \`motir plan\` joins the conversation once there is a tree to evolve.`
+    }
+  );
+}
+async function submitOneShot(client, scope, body) {
+  const session = await client.appendPlanTurn({ ...scope, body });
+  info(`Turn ${session.turnCount} added to the ${scopeLabel(session.targetKeys)} conversation.`);
+  return client.submitPlanSession(scope);
+}
+async function converse(client, scope, readLine) {
+  let session = await client.openPlanSession(scope);
+  info(renderThread(session));
+  info("");
+  info(loopCommands());
+  info("");
+  for (; ; ) {
+    const input = classifyInput(await readLine("plan> "));
+    switch (input.kind) {
+      case "none":
+        continue;
+      case "help":
+        info(loopCommands());
+        continue;
+      case "unknown":
+        info(
+          `Unknown command ${input.input}. Type /help for the list, or plain text to add a turn.`
+        );
+        continue;
+      case "exit":
+        info(
+          `Left the conversation \u2014 ${session.turnCount} turn${session.turnCount === 1 ? "" : "s"} saved and nothing submitted. Re-enter any time; the thread continues where it stopped.`
+        );
+        return null;
+      case "turn":
+        session = await client.appendPlanTurn({ ...scope, body: input.body });
+        info(
+          `Turn ${session.turnCount} added \u2014 NOT submitted. /submit sends every turn as one change.`
+        );
+        continue;
+      case "submit":
+        return client.submitPlanSession(scope);
+    }
+  }
+}
+function reportDetached(submitted, reviewUrl, targetKeys) {
+  out(`Job: ${submitted.jobId} \xB7 Plan: ${submitted.planId}`);
+  if (reviewUrl) out(`Review: ${reviewUrl}`);
+  out("");
+  out("The planner runs in the background \u2014 nothing here waited for it.");
+  out(PROPOSALS_NOT_WORK_ITEMS);
+  out("");
+  out(nextStepHint(reviewUrl, targetKeys));
+}
+async function watchAndShow(client, planId, reviewUrl, targetKeys, deps) {
+  const now = deps.now ?? Date.now;
+  const sleep = deps.sleep ?? delay;
+  const started = now();
+  info(
+    `Waiting for the planner (up to ${Math.round(WATCH_TIMEOUT_MS / 6e4)} minutes; --detach skips the wait)\u2026`
+  );
+  for (; ; ) {
+    const verdict = watchVerdict(await client.getPlanStatus({ planId }));
+    if (verdict.kind === "ready") break;
+    if (verdict.kind === "failed") {
+      throw new CliError(
+        verdict.reachable ? `The planning job failed \u2014 ${verdict.code}: ${verdict.message}` : `Motir could not reach the AI planner \u2014 ${verdict.code}: ${verdict.message}`,
+        {
+          hint: `Your turns are intact on the thread \u2014 re-run and /submit to retry. Plan ${planId}` + (reviewUrl ? ` \xB7 ${reviewUrl}` : "")
+        }
+      );
+    }
+    if (now() - started >= WATCH_TIMEOUT_MS) {
+      throw new CliError(
+        `Plan ${planId} was still generating after ${Math.round(
+          WATCH_TIMEOUT_MS / 6e4
+        )} minutes \u2014 giving up on the wait, not on the plan.`,
+        {
+          hint: reviewUrl ? `It may still land: ${reviewUrl}. Use --detach to submit without waiting.` : "It may still land. Use --detach to submit without waiting."
+        }
+      );
+    }
+    await sleep(WATCH_POLL_MS);
+  }
+  const plan = await client.getPlan({ planId });
+  out(renderPlan(plan));
+  out("");
+  out(nextStepHint(reviewUrl, targetKeys));
+}
+
+// src/help.ts
+import { Help } from "commander";
+var HELP_GROUP = {
+  setup: "SETUP COMMANDS:",
+  read: "READ COMMANDS:",
+  workLoop: "WORK LOOP COMMANDS:",
+  topics: "HELP TOPICS:",
+  additional: "ADDITIONAL COMMANDS:"
+};
+var FLAGS_HEADING = "FLAGS:";
+function agentCredentialEnvNames() {
+  const names = AGENT_PROFILES.flatMap((profile) => profile.credentialEnv);
+  return [...new Set(names)].sort();
+}
+var ENVIRONMENT_TOPIC = {
+  name: "environment",
+  summary: "Environment variables Motir reads, and what each one overrides.",
+  body: () => [
+    "ENVIRONMENT VARIABLES",
+    "",
+    "  Motir reads seven environment variables. None is required \u2014 each one",
+    "  overrides a default, and every value stays where you put it: the CLI",
+    "  never echoes a variable back.",
+    "",
+    "  MOTIR_TOKEN",
+    "    A personal access token, honoured by EVERY command. Set it and there",
+    "    is no login step and no file: nothing is written to disk, which is",
+    "    what makes it the tier for CI, a container, or any box whose config",
+    "    dir is read-only. It outranks a stored credential \u2014 so a stale one",
+    "    exported in a shell profile silently wins; `motir auth status` names",
+    "    the source it used for exactly that reason. Empty counts as unset.",
+    "    Precedence:  --token <pat>  >  MOTIR_TOKEN  >  config.json",
+    "",
+    "  MOTIR_SERVER",
+    "    Which Motir server to talk to \u2014 the self-hosting counterpart of the",
+    "    default, " + DEFAULT_SERVER_URL + ". It outranks the .motir.json link",
+    "    because a container has no link to walk up to. Empty counts as unset.",
+    "    Precedence:  --server <url>  >  MOTIR_SERVER  >  .motir.json  >",
+    "                 the single stored server  >  " + DEFAULT_SERVER_URL,
+    "",
+    "  MOTIR_AGENT",
+    "    The coding agent Motir preflights on your behalf \u2014 a full command",
+    '    line, e.g. "claude --dangerously-skip-permissions". Motir is BYOK:',
+    "    the agent authenticates with its OWN key, which Motir never reads.",
+    "    Precedence:  --agent <cmd>  >  MOTIR_AGENT  >  agentCommand in config.json",
+    "",
+    "  MOTIR_CONFIG_HOME",
+    "    The directory Motir keeps its `motir/config.json` under. Highest",
+    "    precedence of the three config-home sources \u2014 and the second-choice",
+    "    STATE home, so relocating it still moves the whole CLI state.",
+    "",
+    "  XDG_CONFIG_HOME",
+    "    The standard XDG config home, used when MOTIR_CONFIG_HOME is unset.",
+    "    Precedence:  MOTIR_CONFIG_HOME  >  XDG_CONFIG_HOME  >  ~/.config",
+    "",
+    "  MOTIR_STATE_HOME",
+    "    Where Motir keeps `motir/session-excludes.json` \u2014 mutable state, not",
+    "    a credential, which is why it does not live beside the token: the",
+    "    sandbox image mounts the config dir read-only, leaving no writable",
+    "    state directory there at all.",
+    "    Precedence:  MOTIR_STATE_HOME  >  MOTIR_CONFIG_HOME  >",
+    "                 XDG_STATE_HOME  >  ~/.local/state",
+    "",
+    "  XDG_DATA_HOME",
+    "    The standard XDG data home. Motir keeps nothing here \u2014 `motir doctor`",
+    "    reads it only to know where your AGENT keeps its credential (OpenCode",
+    "    signs in to $XDG_DATA_HOME/opencode/auth.json).",
+    "    Precedence:  XDG_DATA_HOME  >  ~/.local/share",
+    "",
+    "  Probed, never read: `motir doctor` asks whether your agent\u2019s own key",
+    "  variable is SET \u2014 one of " + agentCredentialEnvNames().join(", ") + " \u2014",
+    "  so it can report the agent as signed in without opening anything. That",
+    "  check is a presence predicate; the value is never obtained.",
+    "",
+    "  See also: `motir help files`."
+  ].join("\n")
+};
+var FILES_TOPIC = {
+  name: "files",
+  summary: "The files Motir keeps: the credential store, the project link, the exclude list.",
+  body: () => [
+    "FILES",
+    "",
+    "  Motir keeps three files. Only one holds a secret, and it is not the one",
+    "  that lives in your repo.",
+    "",
+    "  ~/.config/motir/config.json          (secret \u2014 never commit)",
+    "    The credential store \u2014 the only FILE a personal access token is ever",
+    "    written to, chmod 600 inside a 0700 directory. Keyed by server URL, so",
+    "    one machine can hold tokens for several Motir servers. Also holds",
+    "    `agentCommand`, the coding agent you configured. (MOTIR_TOKEN is the",
+    "    other way to supply a token, and it is never written anywhere.)",
+    "    Relocate it with MOTIR_CONFIG_HOME or XDG_CONFIG_HOME",
+    "    (`motir help environment`).",
+    "",
+    "  .motir.json                          (no secret \u2014 safe to commit)",
+    "    The project link at your workspace root: the server, workspace and",
+    "    project this folder is bound to, plus an optional `repos` override",
+    "    map. It carries no credential, so it belongs in version control.",
+    "    Every command resolves it by walking UPWARD from the current",
+    "    directory, so any command works from inside any checkout under the",
+    "    root. Repo checkouts otherwise resolve by convention, as",
+    "    <root>/<repoName>; the `repos` map carries overrides only.",
+    "",
+    "  ~/.local/state/motir/session-excludes.json   (no secret)",
+    "    The session exclude list: the ids and keys of items whose dispatch",
+    "    FAILED, so the next run moves past them instead of re-picking the",
+    "    same failure. State, not a credential \u2014 which is why it does not sit",
+    "    beside the token: the sandbox mounts the config dir read-only, and a",
+    "    run must never die because it could not write this file. If it is",
+    "    unwritable Motir warns once and continues; a failed item is already",
+    "    held out of the ready set by its In Progress status.",
+    "    Relocate it with MOTIR_STATE_HOME (`motir help environment`).",
+    "",
+    "  The first two are inspected by `motir doctor`, which reports whether",
+    "  they exist and resolve \u2014 never what is in them.",
+    "",
+    "  See also: `motir help environment`."
+  ].join("\n")
+};
+var HELP_TOPICS = [ENVIRONMENT_TOPIC, FILES_TOPIC];
+function findHelpTopic(name) {
+  return HELP_TOPICS.find((topic) => topic.name === name);
+}
+var EXAMPLES = [
+  "EXAMPLES:",
+  "  $ motir auth login --server https://app.motir.co   # store a token",
+  "  $ motir link --project MOTIR                       # bind this folder",
+  "  $ motir doctor                                     # preflight the setup",
+  "  $ motir ready --kinds subtask --assignee me        # what can I pick up?",
+  "  $ motir status --json                              # the project pulse",
+  "  $ motir sprint                                     # what\u2019s in the active sprint",
+  "  $ motir show MOTIR-7                               # the item, its edges, its body",
+  "  $ motir open MOTIR-7 --print                       # the item\u2019s URL",
+  "  $ motir auto --agent claude --max 5                # drain 5 items unattended",
+  "  $ motir batch --agent claude                       # snapshot now, one PR each",
+  '  $ motir plan "split the billing epic"              # plan by talking; prints proposals'
+].join("\n");
+var LEARN_MORE = [
+  "LEARN MORE:",
+  "  Use `motir <command> --help` for the flags of a single command.",
+  `  Use \`motir help <topic>\` for a topic: ${HELP_TOPICS.map((t) => t.name).join(", ")}.`,
+  "  Read packages/cli/README.md in the Motir checkout for the full guide."
+].join("\n");
+function renderFlagsSection(program, error) {
+  const helper = program.createHelp();
+  const output = program.configureOutput();
+  const helpWidth = error ? output.getErrHelpWidth?.() : output.getOutHelpWidth?.();
+  helper.prepareContext({ error, ...helpWidth === void 0 ? {} : { helpWidth } });
+  const options = Help.prototype.visibleOptions.call(helper, program);
+  if (options.length === 0) return "";
+  const terms = options.map((option) => helper.styleOptionTerm(helper.optionTerm(option)));
+  const termWidth = Math.max(
+    helper.padWidth(program, helper),
+    ...terms.map((term) => helper.displayWidth(term))
+  );
+  const items = options.map(
+    (option, index) => helper.formatItem(
+      terms[index] ?? "",
+      termWidth,
+      helper.styleOptionDescription(helper.optionDescription(option)),
+      helper
+    )
+  );
+  return helper.formatItemList(FLAGS_HEADING, items, helper).join("\n").trimEnd();
+}
+function applyHelpConfiguration(program) {
+  program.commandsGroup(HELP_GROUP.additional);
+  program.configureHelp({
+    // Group and command order is AUTHORED (registration order), not alphabetical.
+    sortSubcommands: false,
+    sortOptions: false,
+    visibleOptions(cmd) {
+      if (cmd === program) return [];
+      return Help.prototype.visibleOptions.call(this, cmd);
+    }
+  });
+}
+function registerHelpSurface(program) {
+  program.helpCommand(false);
+  program.command("help [command...]").description("Show help for a command, or read a help topic.").helpGroup(HELP_GROUP.topics).action((path = []) => {
+    helpAction(program, path);
+  });
+  for (const topic of HELP_TOPICS) {
+    program.command(topic.name).description(topic.summary).helpGroup(HELP_GROUP.topics).action(() => {
+      out(topic.body());
+    });
+  }
+  program.addHelpText("after", (context) => {
+    if (context.command !== program) return "";
+    const blocks = [renderFlagsSection(program, context.error), EXAMPLES, LEARN_MORE].filter(
+      (block) => block !== ""
+    );
+    return blocks.length === 0 ? "" : `
+${blocks.join("\n\n")}`;
+  });
+  program.allowExcessArguments();
+  program.action((_options, command) => {
+    const unknown = command.args[0];
+    if (unknown !== void 0) throw unknownCommandError(unknown);
+    program.outputHelp();
+  });
+}
+function unknownCommandError(name) {
+  return new CliError(`Unknown command "${name}".`, {
+    hint: "Run `motir help` to see the available commands and topics."
+  });
+}
+function helpAction(program, path) {
+  if (path.length === 0) {
+    program.outputHelp();
+    return;
+  }
+  if (path.length === 1) {
+    const topic = findHelpTopic(path[0]);
+    if (topic) {
+      out(topic.body());
+      return;
+    }
+  }
+  let command = program;
+  for (const name of path) {
+    const child = command.commands.find(
+      (candidate) => candidate.name() === name || candidate.aliases().includes(name)
+    );
+    if (!child) {
+      throw new CliError(`No help topic or command named "${path.join(" ")}".`, {
+        hint: "Run `motir help` to see the available commands and topics."
+      });
+    }
+    command = child;
+  }
+  command.outputHelp();
+}
+
+// src/program.ts
+function buildProgram() {
+  const program = new Command2();
+  program.name("motir").description(
+    "Motir CLI \u2014 terminal dispatch of the work loop (an MCP client of the Motir server)."
+  ).version(CLI_VERSION, "-v, --version", "Print the CLI version.");
+  applyHelpConfiguration(program);
+  const auth = program.command("auth").description("Authenticate to a Motir server with a PAT.").helpGroup(HELP_GROUP.setup);
+  auth.command("login").description("Validate and store a personal access token for a server.").option("--server <url>", "Server base URL, e.g. https://app.motir.co").option("--token <pat>", "Personal access token (or set MOTIR_TOKEN; prompted if omitted).").action(authLogin);
+  auth.command("status").description("Show the resolved server, token prefix, and owning user.").option("--server <url>", "Server to report (defaults to the linked / single server).").action(authStatus);
+  auth.command("logout").description("Remove the stored token for a server.").option("--server <url>", "Server to log out of (defaults to the linked / single server).").action(authLogout);
+  const link = program.command("link").description("Bind this workspace-root folder to a server + workspace + project.").helpGroup(HELP_GROUP.setup).option("--server <url>", "Server base URL (defaults to the existing link / single server).").option("--workspace <slug>", "Workspace slug (defaults to the token\u2019s active workspace).").option("--project <key>", "Project key, e.g. PROD.").option(
+    "--repo <name>",
+    'Mark THIS directory as a single repo\u2019s checkout (writes a "." override).'
+  ).action(linkCommand);
+  link.command("add <repo> <path>").description("Add a repo checkout-path override (relative to the link root, or absolute).").action(linkAddCommand);
+  link.command("remove <repo>").description("Remove a repo checkout-path override.").action(linkRemoveCommand);
+  program.command("ready").description("List the linked project\u2019s ready set (every dependency satisfied).").helpGroup(HELP_GROUP.read).option("--kinds <list>", "Comma-separated kinds: epic,story,task,bug,subtask.").option("--assignee <id>", 'Filter by assignee: a user id, "me", or "unassigned".').option("--json", "Emit the ready items as JSON.").action(readyCommand);
+  program.command("status").description("Show the project pulse: ready / in-flight counts + the active sprint.").helpGroup(HELP_GROUP.read).option("--json", "Emit the pulse as JSON.").action(statusCommand);
+  program.command("sprints").description("List the project\u2019s sprints: state, item count, points, window.").helpGroup(HELP_GROUP.read).option("--state <state>", "Only sprints in this state: planned, active, or complete.").option("--json", "Emit the sprint rows as JSON.").action(sprintsCommand);
+  program.command("sprint [ref]").description("List ONE sprint\u2019s work items (defaults to the active sprint).").helpGroup(HELP_GROUP.read).option("--kinds <list>", "Comma-separated kinds: epic,story,task,bug,subtask.").option("--json", "Emit the sprint and its items as JSON.").action((ref, opts) => sprintCommand(ref, opts));
+  program.command("show <key>").description("Read one work item (e.g. PROD-7): fields, readiness, children, edges, body.").helpGroup(HELP_GROUP.read).option("--json", "Emit the get_work_item payload as JSON.").action(showCommand);
+  program.command("doctor").description(
+    "Preflight your BYOK setup: auth, project link, agent binary, credential presence."
+  ).helpGroup(HELP_GROUP.setup).option("--agent <cmd>", "Check THIS agent command instead of the configured one.").option("--json", "Emit the check results as JSON.").action((opts) => doctorCommand(opts));
+  program.command("open <key>").description("Open a work item (e.g. PROD-7) in the browser; prints the URL.").helpGroup(HELP_GROUP.read).option("--print", "Print the URL only; do not launch a browser.").action(openCommand);
+  program.command("next").description("Dispatch the next ready work item: claim it and deliver its prompt.").helpGroup(HELP_GROUP.workLoop).option("--kinds <list>", "Comma-separated kinds: epic,story,task,bug,subtask.").option("--print", "Print the prompt to stdout instead of launching an agent (default).").option("--agent <cmd>", "Run THIS agent command on the prompt (overrides MOTIR_AGENT).").option("--reset", "Clear this project\u2019s session exclude list before picking.").action(nextCommand);
+  program.command("run <key>").description("Dispatch a SPECIFIC work item (e.g. PROD-7), ready or forced.").helpGroup(HELP_GROUP.workLoop).option("--print", "Print the prompt to stdout instead of launching an agent (default).").option("--agent <cmd>", "Run THIS agent command on the prompt (overrides MOTIR_AGENT).").option("--force", "Dispatch even though the item is not ready (dependencies unmet).").action(runCommand);
+  program.command("auto").description("Drain the ready set unattended: one item at a time onto a session branch.").helpGroup(HELP_GROUP.workLoop).option("--agent <cmd>", "Run THIS agent command on every prompt (overrides MOTIR_AGENT).").option("--kinds <list>", "Comma-separated kinds: epic,story,task,bug,subtask.").option("--max <n>", "Stop after dispatching n work items.").option("--keep-going", "Continue past a failed agent instead of halting on the first one.").option("--reset", "Clear this project\u2019s session exclude list before starting.").option(
+    "--include-planning",
+    "Trigger an AI expansion for each unexpanded epic/story instead of skipping it. Never waits: the plan needs your approval."
+  ).option("--print", "Not supported \u2014 an unattended loop has nobody to paste a prompt.").action((opts) => autoCommand(opts));
+  program.command("batch").description("Implement a FROZEN snapshot of the ready set: one pull request per item.").helpGroup(HELP_GROUP.workLoop).option("--agent <cmd>", "Run THIS agent command on every prompt (overrides MOTIR_AGENT).").option("--kinds <list>", "Comma-separated kinds: epic,story,task,bug,subtask.").option("--max <n>", "Stop after dispatching n work items.").option("--keep-going", "Continue past a failed agent instead of halting on the first one.").option("--reset", "Clear this project\u2019s session exclude list before snapshotting.").option("--print", "Not supported \u2014 a frozen snapshot has nobody to paste a prompt.").action((opts) => batchCommand(opts));
+  program.command("plan [args...]").description("Plan by talking: resume the project\u2019s planning conversation, add turns, submit.").helpGroup(HELP_GROUP.workLoop).option("--detach", "Submit and return with the job/plan ids; do not wait for the planner.").addHelpText(
+    "after",
+    [
+      "",
+      "Leading MOTIR-<n> arguments ANCHOR the conversation at those items; the rest is a turn.",
+      "",
+      "  $ motir plan                       # resume the project-wide conversation",
+      "  $ motir plan MOTIR-42              # resume the conversation anchored at MOTIR-42",
+      '  $ motir plan "split the billing epic"   # one turn, submitted, proposals printed',
+      '  $ motir plan MOTIR-42 "size these" --detach',
+      "",
+      "In the conversation: /submit sends every turn as ONE change, /exit leaves it saved.",
+      "A submit produces PROPOSALS \u2014 approving the plan in Motir is what creates work items."
+    ].join("\n")
+  ).action((args, opts) => planCommand(args, opts));
+  program.command("done [key]").description("Close out a merged item \u2014 or a whole merged session branch.").helpGroup(HELP_GROUP.workLoop).option("--session <branch>", "Bulk close-out: flip every item on this session branch.").option("--via <status>", "Move through this status first (e.g. in_review).").action((key, opts) => doneCommand(key, opts));
+  registerHelpSurface(program);
+  return program;
+}
+
+// src/index.ts
+async function main() {
+  const program = buildProgram();
+  await program.parseAsync(process.argv);
+}
+main().catch((err) => {
+  if (err instanceof CliError) {
+    process.stderr.write(`Error: ${err.message}
+`);
+    if (err.hint) process.stderr.write(`Hint: ${err.hint}
+`);
+    process.exit(err.exitCode);
+  }
+  const detail = err instanceof Error ? err.stack ?? err.message : String(err);
+  process.stderr.write(`Unexpected error: ${detail}
+`);
+  process.exit(1);
+});