@impulselab/hepha 0.2.179 → 0.2.181

package/dist/index.js

@@ -1,16 +1,5 @@
 #!/usr/bin/env node
 
-// src/lib/config.ts
-import {
-  chmodSync,
-  mkdirSync,
-  readFileSync,
-  rmSync,
-  writeFileSync
-} from "fs";
-import { homedir } from "os";
-import { dirname, join } from "path";
-
 // ../../packages/core/src/tagged-error.ts
 var TaggedError = class _TaggedError extends Error {
   _tag;
@@ -27,7 +16,7 @@ var TaggedError = class _TaggedError extends Error {
   }
 };
 
-// src/lib/errors.ts
+// src/lib/shared/errors-constants.ts
 var CLI_ERROR_CODES = {
   BAD_USAGE: "BAD_USAGE",
   /** The session needs a person — the exit-3 family. */
@@ -43,6 +32,8 @@ var CLI_ERROR_CODES = {
   NON_JSON_RESPONSE: "NON_JSON_RESPONSE",
   ERROR: "ERROR"
 };
+
+// src/lib/cli/cli-error.ts
 var CliError = class extends TaggedError {
   exitCode;
   details;
@@ -74,91 +65,7 @@ var CliError = class extends TaggedError {
   }
 };
 
-// src/lib/is-http-url.ts
-function isHttpUrl(value) {
-  try {
-    const parsed = new URL(value);
-    return parsed.protocol === "http:" || parsed.protocol === "https:";
-  } catch {
-    return false;
-  }
-}
-
-// src/lib/config.ts
-var CONFIG_PATH = join(homedir(), ".hepha", "config.json");
-var DEFAULT_BASE_URL = "https://hephaistos.impulselab.ai";
-function readFileAsObject() {
-  try {
-    const parsed = JSON.parse(readFileSync(CONFIG_PATH, "utf8"));
-    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
-      return {};
-    }
-    return parsed;
-  } catch {
-    return {};
-  }
-}
-function readString(value) {
-  return typeof value === "string" && value.trim() ? value.trim() : void 0;
-}
-function readUser(value) {
-  if (!value || typeof value !== "object") {
-    return void 0;
-  }
-  const candidate = value;
-  const user = {
-    id: readString(candidate.id),
-    name: readString(candidate.name),
-    email: readString(candidate.email)
-  };
-  return user.id && user.name && user.email ? { id: user.id, name: user.name, email: user.email } : void 0;
-}
-function readHttpUrl(value) {
-  const raw = readString(value);
-  return raw && isHttpUrl(raw) ? raw : void 0;
-}
-function isSameOrigin(a, b) {
-  try {
-    return new URL(a).origin === new URL(b).origin;
-  } catch {
-    return false;
-  }
-}
-var config = {
-  path: CONFIG_PATH,
-  load() {
-    const stored = readFileAsObject();
-    const storedBaseUrl = readHttpUrl(stored.baseUrl);
-    const override = readString(process.env.HEPHA_URL);
-    if (override && !readHttpUrl(override)) {
-      throw new CliError(
-        `HEPHA_URL is not a valid http(s) URL: "${override}".`,
-        2
-      );
-    }
-    const baseUrl = readHttpUrl(override) ?? storedBaseUrl ?? DEFAULT_BASE_URL;
-    const token = storedBaseUrl && isSameOrigin(storedBaseUrl, baseUrl) ? readString(stored.token) : void 0;
-    const user = token ? readUser(stored.user) : void 0;
-    return {
-      baseUrl,
-      ...token ? { token } : {},
-      ...user ? { user } : {}
-    };
-  },
-  save(next) {
-    mkdirSync(dirname(CONFIG_PATH), { recursive: true, mode: 448 });
-    writeFileSync(CONFIG_PATH, `${JSON.stringify(next, null, 2)}
-`, {
-      mode: 384
-    });
-    chmodSync(CONFIG_PATH, 384);
-  },
-  clear() {
-    rmSync(CONFIG_PATH, { force: true });
-  }
-};
-
-// src/lib/output.ts
+// src/lib/shared/output-constants.ts
 var COLORS = {
   reset: "\x1B[0m",
   dim: "\x1B[2m",
@@ -184,59 +91,68 @@ var STATUS_COLORS = {
   killed: "red",
   abstained: "yellow"
 };
-function supportsColor() {
+
+// src/lib/ansi/strip-ansi.ts
+function stripAnsi(text) {
+  return text.replace(/\u001b\[\d+m/g, "");
+}
+
+// src/lib/supports/supports-color.ts
+function supportsColor(jsonMode) {
   return process.stdout.isTTY === true && process.env.NO_COLOR === void 0 && !jsonMode;
 }
-var jsonMode = false;
-var out = {
+
+// src/lib/cli/cli-output.ts
+var CliOutput = class {
+  jsonMode = false;
   /** Declared once per run, before anything can fail. */
   setJson(enabled) {
-    jsonMode = enabled;
-  },
+    this.jsonMode = enabled;
+  }
   isJson() {
-    return jsonMode;
-  },
+    return this.jsonMode;
+  }
   json(value) {
     process.stdout.write(`${JSON.stringify(value, null, 2)}
 `);
-  },
+  }
   line(text = "") {
     process.stdout.write(`${text}
 `);
-  },
+  }
   error(text) {
-    process.stderr.write(`${out.paint(`error: ${out.safe(text)}`, "red")}
+    process.stderr.write(`${this.paint(`error: ${this.safe(text)}`, "red")}
 `);
-  },
+  }
   /**
    * The one place a failure is reported. Under `--json` stdout must be
    * parseable, and it was not: failures went to stderr as prose. Success keeps
    * its bare shape, so nothing that already parses stdout has to change.
    */
   failure(error) {
-    if (!jsonMode) {
-      out.error(error.message);
+    if (!this.jsonMode) {
+      this.error(error.message);
       return;
     }
-    out.json({
+    this.json({
       ok: false,
       error: {
         ...error.details.status === void 0 ? {} : { status: error.details.status },
         code: error.code,
-        message: out.safe(error.message),
+        message: this.safe(error.message),
         ...error.details.issues ? { issues: error.details.issues } : {},
         ...error.details.retryAfterSeconds === void 0 ? {} : { retryAfterSeconds: error.details.retryAfterSeconds }
       },
       // Inside the envelope, so stdout stays one parseable document.
       ...error.result === void 0 ? {} : { result: error.result }
     });
-  },
+  }
   paint(text, color) {
-    if (!supportsColor()) {
+    if (!supportsColor(this.jsonMode)) {
       return text;
     }
     return `${COLORS[color] ?? ""}${text}${COLORS.reset}`;
-  },
+  }
   /**
    * Neutralise terminal control sequences in text the platform gives us.
    *
@@ -249,222 +165,300 @@ var out = {
    */
   safe(text) {
     return text.replace(/[\u0000-\u0008\u000b-\u001f\u007f-\u009f]/g, "");
-  },
+  }
   /** `safe`, flattened to one line — anything going into a table cell. */
   cell(text) {
-    return out.safe(text).replace(/\s+/g, " ").trim();
-  },
+    return this.safe(text).replace(/\s+/g, " ").trim();
+  }
   status(status) {
-    return out.paint(status, STATUS_COLORS[status] ?? "reset");
-  },
+    return this.paint(status, STATUS_COLORS[status] ?? "reset");
+  }
   /** Left-aligned two-column block — the shape used by every list command. */
   table(rows) {
     if (rows.length === 0) {
       return;
     }
-    const widths = rows[0].map(
+    const firstRow = rows[0];
+    if (firstRow === void 0) {
+      return;
+    }
+    const widths = firstRow.map(
       (_, column) => Math.max(...rows.map((row) => stripAnsi(row[column] ?? "").length))
     );
     for (const row of rows) {
       const line = row.map((cell, column) => {
-        const padding = widths[column] - stripAnsi(cell).length;
+        const width = widths[column];
+        if (width === void 0) {
+          return cell;
+        }
+        const padding = width - stripAnsi(cell).length;
         return column === row.length - 1 ? cell : cell + " ".repeat(padding);
       }).join("  ");
-      out.line(line.trimEnd());
+      this.line(line.trimEnd());
     }
   }
 };
-function stripAnsi(text) {
-  return text.replace(/\u001b\[\d+m/g, "");
-}
 
-// src/lib/api.ts
-var DEFAULT_TIMEOUT_MS = 3e4;
-function resolveTimeout(override) {
-  if (override !== void 0) {
-    return override;
-  }
-  const raw = process.env.HEPHA_TIMEOUT_MS?.trim();
-  if (!raw) {
-    return DEFAULT_TIMEOUT_MS;
-  }
-  const parsed = Number(raw);
-  if (!Number.isFinite(parsed) || parsed <= 0) {
-    throw new CliError(
-      `HEPHA_TIMEOUT_MS expects a positive number of milliseconds, got "${raw}".`,
-      2
-    );
+// src/lib/output/out.ts
+var out = new CliOutput();
+
+// src/lib/shared/config.ts
+import { chmodSync, mkdirSync, rmSync, writeFileSync } from "fs";
+import { dirname } from "path";
+
+// src/lib/shared/config-constants.ts
+var DEFAULT_BASE_URL = "https://hephaistos.impulselab.ai";
+
+// src/lib/path/config-path-constants.ts
+import { homedir } from "os";
+import { join } from "path";
+var CONFIG_PATH = join(homedir(), ".hepha", "config.json");
+
+// src/lib/file/read-file-as-object.ts
+import { readFileSync } from "fs";
+function readFileAsObject() {
+  try {
+    const parsed = JSON.parse(readFileSync(CONFIG_PATH, "utf8"));
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+      return {};
+    }
+    return parsed;
+  } catch {
+    return {};
   }
-  return parsed;
 }
-function authHeaders(as) {
-  if (as) {
-    return { authorization: `Bearer ${as.token}` };
-  }
-  const apiKey = process.env.HEPHA_API_KEY;
-  if (apiKey) {
-    return { "x-api-key": apiKey };
-  }
-  const token = process.env.HEPHA_TOKEN ?? config.load().token;
-  if (token) {
-    return { authorization: `Bearer ${token}` };
-  }
-  throw new CliError(
-    "Not signed in. Run `hepha login`, or set HEPHA_API_KEY to act as an agent.",
-    1,
-    { code: CLI_ERROR_CODES.NOT_AUTHENTICATED }
-  );
+
+// src/lib/string/config-read-string.ts
+function configReadString(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : void 0;
 }
-function readIssues(payload) {
-  if (!payload || typeof payload !== "object") {
-    return void 0;
-  }
-  const data = payload.data;
-  if (!data || typeof data !== "object") {
+
+// src/lib/user/read-user.ts
+function readUser(value) {
+  if (!value || typeof value !== "object") {
     return void 0;
   }
-  const issues = data.issues;
-  return Array.isArray(issues) ? issues : void 0;
+  const candidate = value;
+  const user = {
+    id: configReadString(candidate.id),
+    name: configReadString(candidate.name),
+    email: configReadString(candidate.email)
+  };
+  return user.id && user.name && user.email ? { id: user.id, name: user.name, email: user.email } : void 0;
 }
-function readString2(payload, key) {
-  if (!payload || typeof payload !== "object") {
-    return void 0;
+
+// src/lib/http/is-http-url.ts
+function isHttpUrl(value) {
+  try {
+    const parsed = new URL(value);
+    return parsed.protocol === "http:" || parsed.protocol === "https:";
+  } catch {
+    return false;
   }
-  const value = payload[key];
-  return typeof value === "string" && value.length > 0 ? value : void 0;
 }
-function retryAfterSeconds(response) {
-  const raw = response.headers.get("retry-after") ?? response.headers.get("x-retry-after");
-  if (!raw) {
-    return void 0;
-  }
-  const seconds = Number(raw.trim());
-  return Number.isFinite(seconds) && seconds >= 0 ? seconds : void 0;
+
+// src/lib/http/read-http-url.ts
+function readHttpUrl(value) {
+  const raw = configReadString(value);
+  return raw && isHttpUrl(raw) ? raw : void 0;
 }
-function messageFrom(status, payload) {
-  const message = readString2(payload, "message");
-  if (message) {
-    return status === 403 && process.env.HEPHA_API_KEY ? `${message} (HEPHA_API_KEY is set and takes precedence over your \`hepha login\` session \u2014 unset it to act as yourself.)` : message;
-  }
-  if (status === 401) {
-    return "Unauthorized \u2014 your credential is missing, expired or revoked.";
+
+// src/lib/same/is-same-origin.ts
+function isSameOrigin(a, b) {
+  try {
+    return new URL(a).origin === new URL(b).origin;
+  } catch {
+    return false;
   }
-  return `Request failed with status ${status}.`;
-}
-function excerpt(text) {
-  const flattened = out.cell(text);
-  return flattened.length > 200 ? `${flattened.slice(0, 200)}\u2026` : flattened;
 }
-async function api(requestPath, options = {}) {
-  const baseUrl = options.as?.baseUrl ?? config.load().baseUrl;
-  const url = new URL(`${baseUrl.replace(/\/$/, "")}/api/v1${requestPath}`);
-  for (const [key, value] of Object.entries(options.query ?? {})) {
-    if (value !== void 0) {
-      url.searchParams.set(key, String(value));
+
+// src/lib/shared/config.ts
+var config = {
+  path: CONFIG_PATH,
+  load() {
+    const stored = readFileAsObject();
+    const storedBaseUrl = readHttpUrl(stored.baseUrl);
+    const override = configReadString(process.env.HEPHA_URL);
+    if (override && !readHttpUrl(override)) {
+      throw new CliError(
+        `HEPHA_URL is not a valid http(s) URL: "${override}".`,
+        2
+      );
     }
+    const baseUrl = readHttpUrl(override) ?? storedBaseUrl ?? DEFAULT_BASE_URL;
+    const token = storedBaseUrl && isSameOrigin(storedBaseUrl, baseUrl) ? configReadString(stored.token) : void 0;
+    const user = token ? readUser(stored.user) : void 0;
+    return {
+      baseUrl,
+      ...token ? { token } : {},
+      ...user ? { user } : {}
+    };
+  },
+  save(next) {
+    mkdirSync(dirname(CONFIG_PATH), { recursive: true, mode: 448 });
+    writeFileSync(CONFIG_PATH, `${JSON.stringify(next, null, 2)}
+`, {
+      mode: 384
+    });
+    chmodSync(CONFIG_PATH, 384);
+  },
+  clear() {
+    rmSync(CONFIG_PATH, { force: true });
   }
-  const headers = {
-    ...authHeaders(options.as),
-    ...options.body === void 0 ? {} : { "content-type": "application/json" }
-  };
-  const method = options.method ?? "GET";
-  const deadline = resolveTimeout(options.timeoutMs);
-  const controller = new AbortController();
-  let abortedBy = null;
-  const timer = setTimeout(() => {
-    abortedBy ??= "timeout";
-    controller.abort();
-  }, deadline);
-  const onInterrupt = () => {
-    abortedBy ??= "interrupt";
-    controller.abort();
-  };
-  process.once("SIGINT", onInterrupt);
-  let response;
-  let text;
-  try {
-    response = await fetch(url, {
-      method,
-      headers,
-      signal: controller.signal,
-      ...options.body === void 0 ? {} : { body: JSON.stringify(options.body) }
-    });
-    text = await response.text();
-  } catch (cause) {
-    if (abortedBy === "interrupt") {
-      throw new CliError(`${method} ${url.pathname} interrupted.`, 130, {
-        code: CLI_ERROR_CODES.INTERRUPTED
-      });
-    }
-    if (abortedBy === "timeout") {
-      throw new CliError(
-        `${method} ${url.pathname} timed out after ${deadline}ms. Raise HEPHA_TIMEOUT_MS if the platform is simply slow.`,
-        1,
-        { code: CLI_ERROR_CODES.TIMEOUT }
-      );
-    }
-    throw new CliError(
-      `Cannot reach ${baseUrl}. Set HEPHA_URL if the platform lives elsewhere. (${String(cause)})`,
-      1,
-      { code: CLI_ERROR_CODES.NETWORK }
-    );
-  } finally {
-    clearTimeout(timer);
-    process.removeListener("SIGINT", onInterrupt);
-  }
-  const retryAfter = retryAfterSeconds(response);
-  let payload = null;
-  if (text) {
+};
+
+// src/lib/version/read-version.ts
+import { readFileSync as readFileSync2 } from "fs";
+import { dirname as dirname2, join as join2 } from "path";
+import { fileURLToPath } from "url";
+function readVersion() {
+  let directory = dirname2(fileURLToPath(import.meta.url));
+  for (let depth = 0; depth < 5; depth += 1) {
     try {
-      payload = JSON.parse(text);
-    } catch {
-      const body = excerpt(text);
-      const contentType = response.headers.get("content-type") ?? "unknown";
-      throw new CliError(
-        response.ok ? `${method} ${url.pathname} answered ${response.status} with a non-JSON body (${contentType}). Is HEPHA_URL pointing at a Hephaistos deployment?${body ? ` Body: ${body}` : ""}` : `${method} ${url.pathname} failed with ${response.status} and a non-JSON body (${contentType}).${body ? ` Body: ${body}` : ""}`,
-        1,
-        {
-          status: response.status,
-          code: CLI_ERROR_CODES.NON_JSON_RESPONSE,
-          ...retryAfter === void 0 ? {} : { retryAfterSeconds: retryAfter }
-        }
+      const manifest = JSON.parse(
+        readFileSync2(join2(directory, "package.json"), "utf8")
       );
-    }
-  }
-  if (!response.ok) {
-    const code = readString2(payload, "code") ?? readString2(payload, "error");
-    const issues = readIssues(payload);
-    throw new CliError(
-      messageFrom(response.status, payload) + (response.status === 429 && retryAfter !== void 0 ? ` Retry in ${retryAfter}s.` : ""),
-      1,
-      {
-        status: response.status,
-        ...code ? { code } : {},
-        ...issues ? { issues } : {},
-        ...retryAfter === void 0 ? {} : { retryAfterSeconds: retryAfter }
+      const version = manifest.version;
+      if (typeof version === "string" && version.length > 0) {
+        return version;
       }
-    );
+    } catch {
+    }
+    const parent = dirname2(directory);
+    if (parent === directory) {
+      break;
+    }
+    directory = parent;
   }
-  return payload;
+  return "unknown";
 }
 
-// src/lib/api-path.ts
-function path(strings, ...values) {
-  return strings.reduce(
-    (accumulator, literal, index) => accumulator + (index === 0 ? "" : encodeURIComponent(values[index - 1] ?? "")) + literal,
-    ""
-  );
+// src/lib/version/version-constants.ts
+var VERSION = readVersion();
+
+// src/commands/help/help-constants.ts
+var HELP = `hepha \u2014 orchestrate Hephaistos sessions from a terminal or an agent.
+
+USAGE
+  hepha <command> [args] [--flags]
+
+THE LOOP
+  hepha run "<prompt>" --repo owner/repo --follow
+      Start a session and follow it until it finishes or asks you something.
+      Exit 0 completed \xB7 3 waiting on a human \xB7 1 failed.
+      [--title "\u2026"] [--task-type implement|new-project|question|draft|orchestrator]
+      [--model <slug>] [--harness claude-code|codex] [--branch <name>]
+      [--skill <id>]\u2026
+  hepha questions list [--session <id>]
+  hepha questions show <batchId>
+  hepha questions answer <batchId> --option <questionId>=1,2 --text <questionId>="\u2026"
+                                   [--answers '<json array>']
+  hepha questions cancel <batchId>
+  hepha approvals list | show <id> | approve <id> | reject <id> --mode rework --feedback "\u2026"
+
+SESSIONS
+  hepha sessions list [--status active|waiting|done] [--repo owner/repo]
+                      [--search "\u2026"] [--page N] [--limit N] [--all]
+  hepha sessions get <id>
+  hepha sessions logs <id> [--after <sequence>] [--limit N] [--follow]
+  hepha sessions send <id> "<message>"
+  hepha sessions pause|resume|archive <id>
+  hepha sessions kill <id> [--reason "\u2026"]
+  hepha sessions checks|pr|verify <id>
+
+CATALOG
+  hepha repos
+  hepha branches <owner/repo>
+  hepha models
+  hepha skills
+
+AUTH
+  hepha login [--url https://\u2026]     Device authorization: approve it in a browser.
+  hepha logout
+  hepha whoami
+  hepha keys list
+  hepha keys create <name> [--scope sessions:read]\u2026 [--expires-in-days 90]
+  hepha keys revoke <keyId>
+
+ENVIRONMENT
+  HEPHA_API_KEY     Act as an agent. Takes precedence over a stored login, so
+                    the human-only commands (approvals approve/reject, keys)
+                    answer 403 while it is set \u2014 unset it to act as yourself.
+  HEPHA_TOKEN       A device-flow session token, instead of ~/.hepha/config.json.
+  HEPHA_URL         Platform base URL.
+  HEPHA_TIMEOUT_MS  Per-request timeout in milliseconds (default 30000).
+
+GLOBAL FLAGS
+  --json          Machine-readable output on stdout. Every command that
+                  returns data honours it; login is interactive and does not.
+                  Failures print {"ok":false,"error":{\u2026}} and keep their exit code.
+  --quiet         Suppress the streamed transcript while following a session.
+  --version       Print the version and exit.
+  --help          Print this.
+
+Unknown flags and surplus arguments are refused: for an agent, a typo must
+fail rather than run with default options.
+
+`;
+
+// src/commands/command/help-command.ts
+function helpCommand() {
+  const baseUrl = config.load().baseUrl.replace(/\/$/, "");
+  out.line(`${HELP}hepha ${VERSION} \xB7 full reference: ${baseUrl}/api/v1/docs`);
 }
 
-// src/lib/args.ts
+// src/lib/args/args-constants.ts
 var GLOBAL_BOOLEANS = ["json", "help", "quiet"];
+
+// src/lib/boolean/boolean-flags-constants.ts
 var BOOLEAN_FLAGS = /* @__PURE__ */ new Set([
   ...GLOBAL_BOOLEANS,
   "follow",
   "all",
   "version"
 ]);
-var args = {
+
+// src/lib/args/parse-flag.ts
+function parseFlag(argv, index, parsed) {
+  const token = argv[index];
+  if (token === void 0) {
+    return index;
+  }
+  const withoutDashes = token.slice(2);
+  const equalsAt = withoutDashes.indexOf("=");
+  let name;
+  let value;
+  if (equalsAt >= 0) {
+    name = withoutDashes.slice(0, equalsAt);
+    value = withoutDashes.slice(equalsAt + 1);
+    if (BOOLEAN_FLAGS.has(name)) {
+      throw new CliError(
+        `--${name} is a boolean flag: pass --${name} to enable it, or omit it. "--${name}=${value}" is not a value.`,
+        2
+      );
+    }
+  } else {
+    name = withoutDashes;
+    const next = argv[index + 1];
+    if (!BOOLEAN_FLAGS.has(name) && next !== void 0 && !next.startsWith("--")) {
+      value = next;
+      index += 1;
+    }
+  }
+  if (value === void 0 || value.trim() === "") {
+    if (!BOOLEAN_FLAGS.has(name)) {
+      throw new CliError(`--${name} expects a value.`, 2);
+    }
+    parsed.booleans.add(name);
+    return index;
+  }
+  parsed.flags[name] = value;
+  (parsed.repeated[name] ??= []).push(value);
+  return index;
+}
+
+// src/lib/args/args-parser.ts
+var ArgsParser = class {
   parse(argv) {
     const parsed = {
       positional: [],
@@ -475,6 +469,9 @@ var args = {
     let flagsEnded = false;
     for (let index = 0; index < argv.length; index += 1) {
       const token = argv[index];
+      if (token === void 0) {
+        break;
+      }
       if (!flagsEnded && token === "--") {
         flagsEnded = true;
         continue;
@@ -483,39 +480,10 @@ var args = {
         parsed.positional.push(token);
         continue;
       }
-      const withoutDashes = token.slice(2);
-      const equalsAt = withoutDashes.indexOf("=");
-      let name;
-      let value;
-      if (equalsAt >= 0) {
-        name = withoutDashes.slice(0, equalsAt);
-        value = withoutDashes.slice(equalsAt + 1);
-        if (BOOLEAN_FLAGS.has(name)) {
-          throw new CliError(
-            `--${name} is a boolean flag: pass --${name} to enable it, or omit it. "--${name}=${value}" is not a value.`,
-            2
-          );
-        }
-      } else {
-        name = withoutDashes;
-        const next = argv[index + 1];
-        if (!BOOLEAN_FLAGS.has(name) && next !== void 0 && !next.startsWith("--")) {
-          value = next;
-          index += 1;
-        }
-      }
-      if (value === void 0 || value.trim() === "") {
-        if (!BOOLEAN_FLAGS.has(name)) {
-          throw new CliError(`--${name} expects a value.`, 2);
-        }
-        parsed.booleans.add(name);
-        continue;
-      }
-      parsed.flags[name] = value;
-      (parsed.repeated[name] ??= []).push(value);
+      index = parseFlag(argv, index, parsed);
     }
     return parsed;
-  },
+  }
   /**
    * Refuse anything this action does not understand. Called once the action is
    * known, because `sessions list` and `sessions logs` accept different flags.
@@ -539,7 +507,7 @@ var args = {
         2
       );
     }
-  },
+  }
   /** The action name, validated against what the group actually implements. */
   action(parsed, group, allowed, fallback) {
     const action = parsed.positional[0] ?? fallback;
@@ -550,14 +518,14 @@ var args = {
       );
     }
     return action;
-  },
+  }
   required(parsed, index, name) {
     const value = parsed.positional[index];
     if (!value) {
       throw new CliError(`Missing <${name}>.`, 2);
     }
     return value;
-  },
+  }
   /**
    * A whole number inside a range, refused locally: `--page -1` used to come
    * back from the API as a bare "Input validation failed".
@@ -582,7 +550,7 @@ var args = {
       throw new CliError(`--${name} must be at most ${bounds.max}.`, 2);
     }
     return value;
-  },
+  }
   /** One of a fixed set, named in the error so the fix is obvious. */
   choice(parsed, name, allowed) {
     const raw = parsed.flags[name];
@@ -599,34 +567,254 @@ var args = {
   }
 };
 
-// src/lib/version.ts
-import { readFileSync as readFileSync2 } from "fs";
-import { dirname as dirname2, join as join2 } from "path";
-import { fileURLToPath } from "url";
-function readVersion() {
-  let directory = dirname2(fileURLToPath(import.meta.url));
-  for (let depth = 0; depth < 5; depth += 1) {
-    try {
-      const manifest = JSON.parse(
-        readFileSync2(join2(directory, "package.json"), "utf8")
+// src/lib/args/args.ts
+var args = new ArgsParser();
+
+// src/lib/wants/wants-json.ts
+function wantsJson(argv) {
+  for (const token of argv) {
+    if (token === "--") {
+      return false;
+    }
+    if (token === "--json") {
+      return true;
+    }
+  }
+  return false;
+}
+
+// src/lib/api/api-constants.ts
+var DEFAULT_TIMEOUT_MS = 3e4;
+
+// src/lib/timeout/resolve-timeout.ts
+function resolveTimeout(override) {
+  if (override !== void 0) {
+    return override;
+  }
+  const raw = process.env.HEPHA_TIMEOUT_MS?.trim();
+  if (!raw) {
+    return DEFAULT_TIMEOUT_MS;
+  }
+  const parsed = Number(raw);
+  if (!Number.isFinite(parsed) || parsed <= 0) {
+    throw new CliError(
+      `HEPHA_TIMEOUT_MS expects a positive number of milliseconds, got "${raw}".`,
+      2
+    );
+  }
+  return parsed;
+}
+
+// src/lib/auth/auth-headers.ts
+function authHeaders(as) {
+  if (as) {
+    return { authorization: `Bearer ${as.token}` };
+  }
+  const apiKey = process.env.HEPHA_API_KEY;
+  if (apiKey) {
+    return { "x-api-key": apiKey };
+  }
+  const token = process.env.HEPHA_TOKEN ?? config.load().token;
+  if (token) {
+    return { authorization: `Bearer ${token}` };
+  }
+  throw new CliError(
+    "Not signed in. Run `hepha login`, or set HEPHA_API_KEY to act as an agent.",
+    1,
+    { code: CLI_ERROR_CODES.NOT_AUTHENTICATED }
+  );
+}
+
+// src/lib/retry/retry-after-seconds.ts
+function retryAfterSeconds(response) {
+  const raw = response.headers.get("retry-after") ?? response.headers.get("x-retry-after");
+  if (!raw) {
+    return void 0;
+  }
+  const seconds = Number(raw.trim());
+  return Number.isFinite(seconds) && seconds >= 0 ? seconds : void 0;
+}
+
+// src/lib/response/fetch-response.ts
+async function fetchResponse({
+  url,
+  method,
+  headers,
+  body,
+  deadline,
+  baseUrl
+}) {
+  const controller = new AbortController();
+  let abortedBy = null;
+  const timer = setTimeout(() => {
+    abortedBy ??= "timeout";
+    controller.abort();
+  }, deadline);
+  const onInterrupt = () => {
+    abortedBy ??= "interrupt";
+    controller.abort();
+  };
+  process.once("SIGINT", onInterrupt);
+  try {
+    const response = await fetch(url, {
+      method,
+      headers,
+      signal: controller.signal,
+      ...body === void 0 ? {} : { body: JSON.stringify(body) }
+    });
+    return [response, await response.text()];
+  } catch (cause) {
+    if (abortedBy === "interrupt") {
+      throw new CliError(`${method} ${url.pathname} interrupted.`, 130, {
+        code: CLI_ERROR_CODES.INTERRUPTED
+      });
+    }
+    if (abortedBy === "timeout") {
+      throw new CliError(
+        `${method} ${url.pathname} timed out after ${deadline}ms. Raise HEPHA_TIMEOUT_MS if the platform is simply slow.`,
+        1,
+        { code: CLI_ERROR_CODES.TIMEOUT }
       );
-      const version = manifest.version;
-      if (typeof version === "string" && version.length > 0) {
-        return version;
-      }
-    } catch {
     }
-    const parent = dirname2(directory);
-    if (parent === directory) {
-      break;
+    throw new CliError(
+      `Cannot reach ${baseUrl}. Set HEPHA_URL if the platform lives elsewhere. (${String(cause)})`,
+      1,
+      { code: CLI_ERROR_CODES.NETWORK }
+    );
+  } finally {
+    clearTimeout(timer);
+    process.removeListener("SIGINT", onInterrupt);
+  }
+}
+
+// src/lib/api/add-query-parameters.ts
+function addQueryParameters(url, query) {
+  for (const [key, value] of Object.entries(query ?? {})) {
+    if (value !== void 0) {
+      url.searchParams.set(key, String(value));
     }
-    directory = parent;
   }
-  return "unknown";
 }
-var VERSION = readVersion();
 
-// src/lib/expect-shape.ts
+// src/lib/excerpt/excerpt.ts
+function excerpt(text) {
+  const flattened = out.cell(text);
+  return flattened.length > 200 ? `${flattened.slice(0, 200)}\u2026` : flattened;
+}
+
+// src/lib/api/parse-response-payload.ts
+function parseResponsePayload(response, text, request) {
+  const { method, url, retryAfter } = request;
+  if (!text) {
+    return null;
+  }
+  try {
+    return JSON.parse(text);
+  } catch {
+    const body = excerpt(text);
+    const contentType = response.headers.get("content-type") ?? "unknown";
+    throw new CliError(
+      response.ok ? `${method} ${url.pathname} answered ${response.status} with a non-JSON body (${contentType}). Is HEPHA_URL pointing at a Hephaistos deployment?${body ? ` Body: ${body}` : ""}` : `${method} ${url.pathname} failed with ${response.status} and a non-JSON body (${contentType}).${body ? ` Body: ${body}` : ""}`,
+      1,
+      {
+        status: response.status,
+        code: CLI_ERROR_CODES.NON_JSON_RESPONSE,
+        ...retryAfter === void 0 ? {} : { retryAfterSeconds: retryAfter }
+      }
+    );
+  }
+}
+
+// src/lib/issues/read-issues.ts
+function readIssues(payload) {
+  if (!payload || typeof payload !== "object") {
+    return void 0;
+  }
+  const data = payload.data;
+  if (!data || typeof data !== "object") {
+    return void 0;
+  }
+  const issues = data.issues;
+  return Array.isArray(issues) ? issues : void 0;
+}
+
+// src/lib/string/read-string.ts
+function readString(payload, key) {
+  if (!payload || typeof payload !== "object") {
+    return void 0;
+  }
+  const value = payload[key];
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+
+// src/lib/message/message-from.ts
+function messageFrom(status, payload) {
+  const message = readString(payload, "message");
+  if (message) {
+    return status === 403 && process.env.HEPHA_API_KEY ? `${message} (HEPHA_API_KEY is set and takes precedence over your \`hepha login\` session \u2014 unset it to act as yourself.)` : message;
+  }
+  if (status === 401) {
+    return "Unauthorized \u2014 your credential is missing, expired or revoked.";
+  }
+  return `Request failed with status ${status}.`;
+}
+
+// src/lib/api/throw-response-error.ts
+function throwResponseError(response, payload, retryAfter) {
+  const code = readString(payload, "code") ?? readString(payload, "error");
+  const issues = readIssues(payload);
+  throw new CliError(
+    messageFrom(response.status, payload) + (response.status === 429 && retryAfter !== void 0 ? ` Retry in ${retryAfter}s.` : ""),
+    1,
+    {
+      status: response.status,
+      ...code ? { code } : {},
+      ...issues ? { issues } : {},
+      ...retryAfter === void 0 ? {} : { retryAfterSeconds: retryAfter }
+    }
+  );
+}
+
+// src/lib/api/api.ts
+async function api(requestPath, options = {}) {
+  const baseUrl = options.as?.baseUrl ?? config.load().baseUrl;
+  const url = new URL(`${baseUrl.replace(/\/$/, "")}/api/v1${requestPath}`);
+  addQueryParameters(url, options.query);
+  const headers = {
+    ...authHeaders(options.as),
+    ...options.body === void 0 ? {} : { "content-type": "application/json" }
+  };
+  const method = options.method ?? "GET";
+  const deadline = resolveTimeout(options.timeoutMs);
+  const [response, text] = await fetchResponse({
+    url,
+    method,
+    headers,
+    body: options.body,
+    deadline,
+    baseUrl
+  });
+  const retryAfter = retryAfterSeconds(response);
+  const payload = parseResponsePayload(response, text, {
+    method,
+    url,
+    retryAfter
+  });
+  if (!response.ok) {
+    throwResponseError(response, payload, retryAfter);
+  }
+  return payload;
+}
+
+// src/lib/path/path.ts
+function path(strings, ...values) {
+  return strings.reduce(
+    (accumulator, literal, index) => accumulator + (index === 0 ? "" : encodeURIComponent(values[index - 1] ?? "")) + literal,
+    ""
+  );
+}
+
+// src/lib/read/read.ts
 function read(payload, dotted) {
   return dotted.split(".").reduce((current, key) => {
     if (!current || typeof current !== "object") {
@@ -635,6 +823,8 @@ function read(payload, dotted) {
     return current[key];
   }, payload);
 }
+
+// src/lib/expect/expect-shape.ts
 function expectShape(payload, endpoint, requirements) {
   for (const [field, predicate] of Object.entries(requirements)) {
     if (!predicate(read(payload, field))) {
@@ -648,7 +838,7 @@ function expectShape(payload, endpoint, requirements) {
   return payload;
 }
 
-// src/lib/is.ts
+// src/lib/is/is.ts
 var is = {
   string: (value) => typeof value === "string",
   number: (value) => typeof value === "number",
@@ -656,36 +846,42 @@ var is = {
   object: (value) => Boolean(value) && typeof value === "object" && !Array.isArray(value)
 };
 
-// src/commands/approvals.ts
+// src/commands/approvals/approvals-constants.ts
 var ACTIONS = ["list", "show", "approve", "reject"];
 var REJECT_MODES = ["rework", "terminate"];
+
+// src/commands/approvals/list-approvals.ts
+async function listApprovals(asJson) {
+  const result = expectShape(
+    await api("/approvals"),
+    "GET /approvals",
+    { items: is.array }
+  );
+  if (asJson) {
+    out.json(result);
+    return;
+  }
+  if (result.items.length === 0) {
+    out.line("No guardrail waiting on you.");
+    return;
+  }
+  out.table(
+    result.items.map((item) => [
+      out.cell(item.id),
+      out.cell(item.guardrailKind),
+      out.cell(item.repoName ?? "\u2014"),
+      out.cell(item.summary)
+    ])
+  );
+}
+
+// src/commands/command/approvals-command.ts
 async function approvalsCommand(parsed) {
   const action = args.action(parsed, "approvals", ACTIONS, "list");
   const asJson = parsed.booleans.has("json");
   if (action === "list") {
     args.expect(parsed, { positional: 1 });
-    const result2 = expectShape(
-      await api("/approvals"),
-      "GET /approvals",
-      { items: is.array }
-    );
-    if (asJson) {
-      out.json(result2);
-      return;
-    }
-    if (result2.items.length === 0) {
-      out.line("No guardrail waiting on you.");
-      return;
-    }
-    out.table(
-      result2.items.map((item) => [
-        out.cell(item.id),
-        out.cell(item.guardrailKind),
-        out.cell(item.repoName ?? "\u2014"),
-        out.cell(item.summary)
-      ])
-    );
-    return;
+    return await listApprovals(asJson);
   }
   args.expect(parsed, {
     positional: 2,
@@ -748,169 +944,161 @@ async function approvalsCommand(parsed) {
   );
 }
 
-// src/commands/catalog.ts
-async function catalogCommand(topic, parsed) {
-  const asJson = parsed.booleans.has("json");
-  if (topic === "repos") {
-    args.expect(parsed, {});
-    const result = expectShape(
-      await api("/repos"),
-      "GET /repos",
-      { repos: is.array }
+// src/commands/catalog/list-catalog-branches.ts
+async function listCatalogBranches(parsed, asJson) {
+  args.expect(parsed, { positional: 1 });
+  const repoFullName = args.required(parsed, 0, "owner/repo");
+  const segments = repoFullName.split("/");
+  const [owner, repo] = segments;
+  if (segments.length !== 2 || !owner || !repo) {
+    throw new CliError(
+      `Expected a repository as "owner/repo", got "${repoFullName}".`,
+      2
     );
-    if (asJson) {
-      out.json(result);
-      return;
-    }
-    for (const repo of result.repos) {
-      out.line(out.cell(repo));
-    }
-    return;
   }
-  if (topic === "branches") {
-    args.expect(parsed, { positional: 1 });
-    const repoFullName = args.required(parsed, 0, "owner/repo");
-    const segments = repoFullName.split("/");
-    const [owner, repo] = segments;
-    if (segments.length !== 2 || !owner || !repo) {
-      throw new CliError(
-        `Expected a repository as "owner/repo", got "${repoFullName}".`,
-        2
-      );
-    }
-    const result = await api(
-      path`/repos/${owner}/${repo}/branches`
-    );
-    if (!result.result) {
-      throw new CliError(`No GitHub installation covers ${repoFullName}.`);
-    }
-    if (asJson) {
-      out.json(result);
-      return;
-    }
-    for (const branch of result.result.branches) {
-      out.line(
-        branch === result.result.defaultBranch ? `${out.cell(branch)} ${out.paint("(default)", "dim")}` : out.cell(branch)
-      );
-    }
+  const result = await api(
+    path`/repos/${owner}/${repo}/branches`
+  );
+  if (!result.result) {
+    throw new CliError(`No GitHub installation covers ${repoFullName}.`);
+  }
+  if (asJson) {
+    out.json(result);
     return;
   }
-  if (topic === "models") {
-    args.expect(parsed, {});
-    const result = expectShape(
-      await api("/models"),
-      "GET /models",
-      { harnesses: is.array, gatewayModels: is.array }
+  for (const branch of result.result.branches) {
+    out.line(
+      branch === result.result.defaultBranch ? `${out.cell(branch)} ${out.paint("(default)", "dim")}` : out.cell(branch)
     );
-    if (asJson) {
-      out.json(result);
-      return;
-    }
-    out.line(out.paint("harnesses", "dim"));
-    for (const harness of result.harnesses) {
-      out.line(`  ${out.cell(harness)}`);
-    }
-    out.line();
-    out.line(out.paint("gateway models", "dim"));
-    for (const model of result.gatewayModels) {
-      out.line(`  ${out.cell(model.id)}`);
-    }
+  }
+}
+
+// src/commands/catalog/list-catalog-models.ts
+async function listCatalogModels(parsed, asJson) {
+  args.expect(parsed, {});
+  const result = expectShape(
+    await api("/models"),
+    "GET /models",
+    { harnesses: is.array, gatewayModels: is.array }
+  );
+  if (asJson) {
+    out.json(result);
     return;
   }
-  if (topic === "skills") {
-    args.expect(parsed, {});
-    const result = expectShape(
-      await api("/skills"),
-      "GET /skills",
-      { skills: is.array }
-    );
-    if (asJson) {
-      out.json(result);
-      return;
-    }
-    out.table(
-      result.skills.map((skill) => [
-        out.cell(skill.id),
-        out.cell(skill.name),
-        out.cell(skill.description ?? "")
-      ])
-    );
+  out.line(out.paint("harnesses", "dim"));
+  for (const harness of result.harnesses) {
+    out.line(`  ${out.cell(harness)}`);
+  }
+  out.line();
+  out.line(out.paint("gateway models", "dim"));
+  for (const model of result.gatewayModels) {
+    out.line(`  ${out.cell(model.id)}`);
+  }
+}
+
+// src/commands/catalog/read-catalog-list.ts
+async function readCatalogList(parsed, path2, field) {
+  args.expect(parsed, {});
+  return expectShape(await api(path2), `GET ${path2}`, { [field]: is.array });
+}
+
+// src/commands/catalog/list-catalog-repos.ts
+async function listCatalogRepos(parsed, asJson) {
+  const result = await readCatalogList(
+    parsed,
+    "/repos",
+    "repos"
+  );
+  if (asJson) {
+    out.json(result);
     return;
   }
-  throw new CliError(`Unknown catalog topic "${topic}".`, 2);
+  for (const repo of result.repos) {
+    out.line(out.cell(repo));
+  }
 }
 
-// src/commands/help.ts
-var HELP = `hepha \u2014 orchestrate Hephaistos sessions from a terminal or an agent.
-
-USAGE
-  hepha <command> [args] [--flags]
-
-THE LOOP
-  hepha run "<prompt>" --repo owner/repo --follow
-      Start a session and follow it until it finishes or asks you something.
-      Exit 0 completed \xB7 3 waiting on a human \xB7 1 failed.
-      [--title "\u2026"] [--task-type implement|new-project|question|draft|orchestrator]
-      [--model <slug>] [--harness claude-code|codex] [--branch <name>]
-      [--skill <id>]\u2026
-  hepha questions list [--session <id>]
-  hepha questions show <batchId>
-  hepha questions answer <batchId> --option <questionId>=1,2 --text <questionId>="\u2026"
-                                   [--answers '<json array>']
-  hepha questions cancel <batchId>
-  hepha approvals list | show <id> | approve <id> | reject <id> --mode rework --feedback "\u2026"
-
-SESSIONS
-  hepha sessions list [--status active|waiting|done] [--repo owner/repo]
-                      [--search "\u2026"] [--page N] [--limit N] [--all]
-  hepha sessions get <id>
-  hepha sessions logs <id> [--after <sequence>] [--limit N] [--follow]
-  hepha sessions send <id> "<message>"
-  hepha sessions pause|resume|archive <id>
-  hepha sessions kill <id> [--reason "\u2026"]
-  hepha sessions checks|pr|verify <id>
-
-CATALOG
-  hepha repos
-  hepha branches <owner/repo>
-  hepha models
-  hepha skills
-
-AUTH
-  hepha login [--url https://\u2026]     Device authorization: approve it in a browser.
-  hepha logout
-  hepha whoami
-  hepha keys list
-  hepha keys create <name> [--scope sessions:read]\u2026 [--expires-in-days 90]
-  hepha keys revoke <keyId>
+// src/commands/catalog/list-catalog-skills.ts
+async function listCatalogSkills(parsed, asJson) {
+  const result = await readCatalogList(
+    parsed,
+    "/skills",
+    "skills"
+  );
+  if (asJson) {
+    out.json(result);
+    return;
+  }
+  out.table(
+    result.skills.map((skill) => [
+      out.cell(skill.id),
+      out.cell(skill.name),
+      out.cell(skill.description ?? "")
+    ])
+  );
+}
 
-ENVIRONMENT
-  HEPHA_API_KEY     Act as an agent. Takes precedence over a stored login, so
-                    the human-only commands (approvals approve/reject, keys)
-                    answer 403 while it is set \u2014 unset it to act as yourself.
-  HEPHA_TOKEN       A device-flow session token, instead of ~/.hepha/config.json.
-  HEPHA_URL         Platform base URL.
-  HEPHA_TIMEOUT_MS  Per-request timeout in milliseconds (default 30000).
+// src/commands/catalog/catalog-topics.ts
+var catalogTopics = {
+  branches: listCatalogBranches,
+  models: listCatalogModels,
+  repos: listCatalogRepos,
+  skills: listCatalogSkills
+};
 
-GLOBAL FLAGS
-  --json          Machine-readable output on stdout. Every command that
-                  returns data honours it; login is interactive and does not.
-                  Failures print {"ok":false,"error":{\u2026}} and keep their exit code.
-  --quiet         Suppress the streamed transcript while following a session.
-  --version       Print the version and exit.
-  --help          Print this.
+// src/commands/command/catalog-command.ts
+async function catalogCommand(topic, parsed) {
+  const list = catalogTopics[topic];
+  if (!list) {
+    throw new CliError(`Unknown catalog topic "${topic}".`, 2);
+  }
+  await list(parsed, parsed.booleans.has("json"));
+}
 
-Unknown flags and surplus arguments are refused: for an agent, a typo must
-fail rather than run with default options.
+// src/commands/keys/keys-constants.ts
+var ACTIONS2 = ["list", "create", "revoke"];
 
-`;
-function helpCommand() {
-  const baseUrl = config.load().baseUrl.replace(/\/$/, "");
-  out.line(`${HELP}hepha ${VERSION} \xB7 full reference: ${baseUrl}/api/v1/docs`);
+// src/commands/key/create-key.ts
+async function createKey(parsed, asJson) {
+  args.expect(parsed, { flags: ["scope", "expires-in-days"], positional: 2 });
+  const name = args.required(parsed, 1, "name");
+  const scopes = parsed.repeated.scope;
+  const expiresInDays = args.integer(parsed, "expires-in-days", {
+    min: 1,
+    max: 365
+  });
+  const created = expectShape(
+    await api("/keys", {
+      method: "POST",
+      body: {
+        name,
+        ...scopes && scopes.length > 0 ? { scopes } : {},
+        ...expiresInDays !== void 0 ? { expiresInDays } : {}
+      }
+    }),
+    "POST /keys",
+    { key: is.string, scopes: is.array }
+  );
+  if (asJson) {
+    out.json(created);
+    return;
+  }
+  out.line(
+    `${out.paint("\u2713", "green")} Created "${out.cell(created.name ?? name)}"`
+  );
+  out.line();
+  out.line(`  ${out.paint(created.key, "bold")}`);
+  out.line();
+  out.line(
+    out.paint(
+      "  Copy it now \u2014 it is hashed at rest and never shown again.",
+      "dim"
+    )
+  );
+  out.line(out.paint(`  Scopes: ${created.scopes.join(" ")}`, "dim"));
 }
 
-// src/commands/keys.ts
-var ACTIONS2 = ["list", "create", "revoke"];
+// src/commands/command/keys-command.ts
 async function keysCommand(parsed) {
   const action = args.action(parsed, "keys", ACTIONS2, "list");
   const asJson = parsed.booleans.has("json");
@@ -946,46 +1134,7 @@ async function keysCommand(parsed) {
     return;
   }
   if (action === "create") {
-    args.expect(parsed, {
-      flags: ["scope", "expires-in-days"],
-      positional: 2
-    });
-    const name = args.required(parsed, 1, "name");
-    const scopes = parsed.repeated.scope;
-    const expiresInDays = args.integer(parsed, "expires-in-days", {
-      min: 1,
-      max: 365
-    });
-    const created = expectShape(
-      await api("/keys", {
-        method: "POST",
-        body: {
-          name,
-          ...scopes && scopes.length > 0 ? { scopes } : {},
-          ...expiresInDays !== void 0 ? { expiresInDays } : {}
-        }
-      }),
-      "POST /keys",
-      { key: is.string, scopes: is.array }
-    );
-    if (asJson) {
-      out.json(created);
-      return;
-    }
-    out.line(
-      `${out.paint("\u2713", "green")} Created "${out.cell(created.name ?? name)}"`
-    );
-    out.line();
-    out.line(`  ${out.paint(created.key, "bold")}`);
-    out.line();
-    out.line(
-      out.paint(
-        "  Copy it now \u2014 it is hashed at rest and never shown again.",
-        "dim"
-      )
-    );
-    out.line(out.paint(`  Scopes: ${created.scopes.join(" ")}`, "dim"));
-    return;
+    return await createKey(parsed, asJson);
   }
   args.expect(parsed, { positional: 2 });
   const keyId = args.required(parsed, 1, "keyId");
@@ -999,55 +1148,11 @@ async function keysCommand(parsed) {
   out.line(`${out.paint("\u2713", "green")} Revoked ${out.cell(keyId)}`);
 }
 
-// src/commands/login.ts
+// src/commands/command/login-command.ts
 import { createAuthClient } from "better-auth/client";
 import { deviceAuthorizationClient } from "better-auth/client/plugins";
 
-// ../../packages/database/constants.ts
-var USER_ROLES = {
-  ADMIN: "admin",
-  MEMBER: "member"
-};
-var ALL_USER_ROLES = Object.values(USER_ROLES);
-var API_SCOPES = [
-  "sessions:read",
-  "sessions:write",
-  "questions:read",
-  "questions:answer",
-  "approvals:read",
-  "catalog:read",
-  "pull_requests:read"
-];
-var DEFAULT_API_SCOPES = API_SCOPES.filter(
-  (scope) => scope.endsWith(":read")
-);
-var SESSION = {
-  /** Cookie + session row lifetime: 30 days. */
-  EXPIRES_IN: 60 * 60 * 24 * 30,
-  /** Refresh the expiry at most once a day, to avoid a write per request. */
-  UPDATE_AGE: 60 * 60 * 24,
-  /** Cache the session row in memory for this long, to avoid a read per request. */
-  COOKIE_CACHE_MAX_AGE: 60
-};
-var DEVICE_AUTHORIZATION = {
-  /** Only these clients may open a device flow. */
-  CLIENT_IDS: ["hepha-cli"],
-  /** Lifetime of an unapproved user code. */
-  EXPIRES_IN: "15m",
-  /** Minimum delay the CLI must wait between two token polls. */
-  INTERVAL: "5s",
-  /** Page a human visits to approve a pending device. */
-  VERIFICATION_PATH: "/device",
-  /**
-   * Per-IP ceiling on `/device/token`. The window is deliberately SHORTER than
-   * INTERVAL: Better Auth only resets its counter when two requests are further
-   * apart than the window, so a 5s poll under the default 60s window never reset
-   * it and every login 429'd partway through the code's lifetime.
-   */
-  POLL_RATE_LIMIT: { WINDOW_SECONDS: 4, MAX_REQUESTS: 10 }
-};
-
-// src/lib/device-token-error.ts
+// src/lib/token/device-token-error.ts
 var deviceTokenError = {
   /** What the server said, when it said anything at all. */
   message(error) {
@@ -1075,7 +1180,7 @@ var deviceTokenError = {
   }
 };
 
-// src/commands/login-backoff.ts
+// src/commands/next/next-poll-delay.ts
 function nextPollDelay(interval, remainingSeconds) {
   if (remainingSeconds <= 0) {
     return null;
@@ -1083,7 +1188,7 @@ function nextPollDelay(interval, remainingSeconds) {
   return Math.min(interval, remainingSeconds);
 }
 
-// src/lib/open-browser.ts
+// src/lib/browser/open-browser.ts
 import { spawn } from "child_process";
 function openBrowser(url) {
   const command = process.platform === "darwin" ? "open" : process.platform === "win32" ? "cmd" : "xdg-open";
@@ -1100,19 +1205,95 @@ function openBrowser(url) {
   }
 }
 
-// src/commands/login.ts
-var CLIENT_ID = DEVICE_AUTHORIZATION.CLIENT_IDS[0];
+// src/commands/login/login-constants.ts
 var MIN_BACKOFF = 10;
+
+// ../../packages/database/shared/constants.ts
+var USER_ROLES = {
+  ADMIN: "admin",
+  MEMBER: "member"
+};
+var ALL_USER_ROLES = Object.values(USER_ROLES);
+var API_SCOPES = [
+  "sessions:read",
+  "sessions:write",
+  "questions:read",
+  "questions:answer",
+  "approvals:read",
+  "catalog:read",
+  "pull_requests:read"
+];
+var DEFAULT_API_SCOPES = API_SCOPES.filter(
+  (scope) => scope.endsWith(":read")
+);
+var SESSION = {
+  /** Cookie + session row lifetime: 30 days. */
+  EXPIRES_IN: 60 * 60 * 24 * 30,
+  /** Refresh the expiry at most once a day, to avoid a write per request. */
+  UPDATE_AGE: 60 * 60 * 24,
+  /** Cache the session row in memory for this long, to avoid a read per request. */
+  COOKIE_CACHE_MAX_AGE: 60
+};
+var DEVICE_AUTHORIZATION = {
+  /** Only these clients may open a device flow. */
+  CLIENT_IDS: ["hepha-cli"],
+  /** Lifetime of an unapproved user code. */
+  EXPIRES_IN: "15m",
+  /** Minimum delay the CLI must wait between two token polls. */
+  INTERVAL: "5s",
+  /** Page a human visits to approve a pending device. */
+  VERIFICATION_PATH: "/device",
+  /**
+   * Per-IP ceiling on `/device/token`. The window is deliberately SHORTER than
+   * INTERVAL: Better Auth only resets its counter when two requests are further
+   * apart than the window, so a 5s poll under the default 60s window never reset
+   * it and every login 429'd partway through the code's lifetime.
+   */
+  POLL_RATE_LIMIT: { WINDOW_SECONDS: 4, MAX_REQUESTS: 10 }
+};
+
+// src/commands/client/client-id-constants.ts
+var CLIENT_ID = DEVICE_AUTHORIZATION.CLIENT_IDS[0];
+
+// src/commands/sleep/sleep.ts
 function sleep(seconds) {
   return new Promise((resolve) => setTimeout(resolve, seconds * 1e3));
 }
-async function loginCommand(parsed) {
-  args.expect(parsed, { flags: ["url"] });
+
+// src/commands/complete/complete-login.ts
+async function completeLogin(baseUrl, token) {
+  const identity = await api("/me", {
+    as: { baseUrl, token }
+  });
+  config.save({
+    baseUrl,
+    token,
+    user: {
+      id: identity.user.id,
+      name: identity.user.name,
+      email: identity.user.email
+    }
+  });
+  out.line();
+  out.line(
+    `${out.paint("\u2713", "green")} Signed in as ${identity.user.email} on ${baseUrl}`
+  );
+  out.line(out.paint(`  Session stored in ${config.path}`, "dim"));
+}
+
+// src/commands/login/resolve-login-base-url.ts
+function resolveLoginBaseUrl(parsed) {
   const requested = parsed.flags.url?.trim();
   if (requested !== void 0 && !isHttpUrl(requested)) {
     throw new CliError(`--url is not a valid http(s) URL: "${requested}".`, 2);
   }
-  const baseUrl = (requested ?? config.load().baseUrl).replace(/\/$/, "");
+  return (requested ?? config.load().baseUrl).replace(/\/$/, "");
+}
+
+// src/commands/command/login-command.ts
+async function loginCommand(parsed) {
+  args.expect(parsed, { flags: ["url"] });
+  const baseUrl = resolveLoginBaseUrl(parsed);
   const authClient = createAuthClient({
     baseURL: baseUrl,
     plugins: [deviceAuthorizationClient()]
@@ -1154,23 +1335,7 @@ async function loginCommand(parsed) {
       continue;
     }
     if (token?.access_token) {
-      const identity = await api("/me", {
-        as: { baseUrl, token: token.access_token }
-      });
-      config.save({
-        baseUrl,
-        token: token.access_token,
-        user: {
-          id: identity.user.id,
-          name: identity.user.name,
-          email: identity.user.email
-        }
-      });
-      out.line();
-      out.line(
-        `${out.paint("\u2713", "green")} Signed in as ${identity.user.email} on ${baseUrl}`
-      );
-      out.line(out.paint(`  Session stored in ${config.path}`, "dim"));
+      await completeLogin(baseUrl, token.access_token);
       return;
     }
     if (!error) {
@@ -1193,7 +1358,7 @@ async function loginCommand(parsed) {
   throw new CliError("The code expired before it was approved. Try again.");
 }
 
-// src/commands/logout.ts
+// src/commands/command/logout-command.ts
 function logoutCommand(parsed) {
   args.expect(parsed, {});
   config.clear();
@@ -1204,7 +1369,7 @@ function logoutCommand(parsed) {
   out.line("Signed out.");
 }
 
-// src/commands/collect-answers.ts
+// src/commands/answers/collect-answers-constants.ts
 var LIMITS = {
   QUESTION_ID: 40,
   OPTION_ID: 40,
@@ -1212,48 +1377,62 @@ var LIMITS = {
   FREE_TEXT: 1e4,
   ANSWERS: 50
 };
-function validateAnswer(answer, label) {
-  if (answer.questionId.trim().length === 0) {
-    throw new CliError(`${label} needs a non-empty "questionId".`, 2);
+
+// src/commands/answer/validate-free-text.ts
+function validateFreeText(value, label) {
+  if (value === void 0) {
+    return;
   }
-  if (answer.questionId.length > LIMITS.QUESTION_ID) {
+  const freeText = value.trim();
+  if (freeText.length === 0) {
+    throw new CliError(`${label} has empty free text.`, 2);
+  }
+  if (freeText.length > LIMITS.FREE_TEXT) {
     throw new CliError(
-      `${label} has a "questionId" longer than ${LIMITS.QUESTION_ID} characters.`,
+      `${label} has free text longer than ${LIMITS.FREE_TEXT} characters.`,
       2
     );
   }
-  const options = answer.selectedOptionIds;
-  if (options !== void 0) {
-    if (options.length > LIMITS.OPTIONS_PER_ANSWER) {
-      throw new CliError(
-        `${label} selects more than ${LIMITS.OPTIONS_PER_ANSWER} options.`,
-        2
-      );
-    }
-    for (const id of options) {
-      if (id.trim().length === 0) {
-        throw new CliError(`${label} has an empty option id.`, 2);
-      }
-      if (id.trim().length > LIMITS.OPTION_ID) {
-        throw new CliError(
-          `${label} has an option id longer than ${LIMITS.OPTION_ID} characters.`,
-          2
-        );
-      }
-    }
+}
+
+// src/commands/answer/validate-selected-option-ids.ts
+function validateSelectedOptionIds(options, label) {
+  if (options === void 0) {
+    return;
   }
-  if (answer.freeText !== void 0) {
-    const freeText = answer.freeText.trim();
-    if (freeText.length === 0) {
-      throw new CliError(`${label} has empty free text.`, 2);
+  if (options.length > LIMITS.OPTIONS_PER_ANSWER) {
+    throw new CliError(
+      `${label} selects more than ${LIMITS.OPTIONS_PER_ANSWER} options.`,
+      2
+    );
+  }
+  for (const id of options) {
+    if (id.trim().length === 0) {
+      throw new CliError(`${label} has an empty option id.`, 2);
     }
-    if (freeText.length > LIMITS.FREE_TEXT) {
+    if (id.trim().length > LIMITS.OPTION_ID) {
       throw new CliError(
-        `${label} has free text longer than ${LIMITS.FREE_TEXT} characters.`,
+        `${label} has an option id longer than ${LIMITS.OPTION_ID} characters.`,
         2
       );
     }
   }
+}
+
+// src/commands/answer/validate-answer.ts
+function validateAnswer(answer, label) {
+  if (answer.questionId.trim().length === 0) {
+    throw new CliError(`${label} needs a non-empty "questionId".`, 2);
+  }
+  if (answer.questionId.length > LIMITS.QUESTION_ID) {
+    throw new CliError(
+      `${label} has a "questionId" longer than ${LIMITS.QUESTION_ID} characters.`,
+      2
+    );
+  }
+  const options = answer.selectedOptionIds;
+  validateSelectedOptionIds(options, label);
+  validateFreeText(answer.freeText, label);
   if ((options === void 0 || options.length === 0) && answer.freeText === void 0) {
     throw new CliError(
       `${label} answers nothing. Give it at least one option id or some free text.`,
@@ -1261,6 +1440,31 @@ function validateAnswer(answer, label) {
     );
   }
 }
+
+// src/commands/answers/parse-answer-entry.ts
+function parseAnswerEntry(entry, label) {
+  if (!entry || typeof entry !== "object" || Array.isArray(entry)) {
+    throw new CliError(`${label} must be an object.`, 2);
+  }
+  const answer = entry;
+  if (typeof answer.questionId !== "string") {
+    throw new CliError(`${label} needs a non-empty "questionId".`, 2);
+  }
+  if (answer.selectedOptionIds !== void 0 && (!Array.isArray(answer.selectedOptionIds) || answer.selectedOptionIds.some((id) => typeof id !== "string"))) {
+    throw new CliError(
+      `${label}.selectedOptionIds must be an array of strings.`,
+      2
+    );
+  }
+  if (answer.freeText !== void 0 && typeof answer.freeText !== "string") {
+    throw new CliError(`${label}.freeText must be a string.`, 2);
+  }
+  const parsed = entry;
+  validateAnswer(parsed, label);
+  return parsed;
+}
+
+// src/commands/answers/parse-answers-flag.ts
 function parseAnswersFlag(raw) {
   let decoded;
   try {
@@ -1281,27 +1485,12 @@ function parseAnswersFlag(raw) {
     );
   }
   for (const [index, entry] of decoded.entries()) {
-    const label = `--answers[${index}]`;
-    if (!entry || typeof entry !== "object" || Array.isArray(entry)) {
-      throw new CliError(`${label} must be an object.`, 2);
-    }
-    const answer = entry;
-    if (typeof answer.questionId !== "string") {
-      throw new CliError(`${label} needs a non-empty "questionId".`, 2);
-    }
-    if (answer.selectedOptionIds !== void 0 && (!Array.isArray(answer.selectedOptionIds) || answer.selectedOptionIds.some((id) => typeof id !== "string"))) {
-      throw new CliError(
-        `${label}.selectedOptionIds must be an array of strings.`,
-        2
-      );
-    }
-    if (answer.freeText !== void 0 && typeof answer.freeText !== "string") {
-      throw new CliError(`${label}.freeText must be a string.`, 2);
-    }
-    validateAnswer(entry, label);
+    parseAnswerEntry(entry, `--answers[${index}]`);
   }
   return decoded;
 }
+
+// src/commands/answers/collect-answers.ts
 function collectAnswers(parsed) {
   if (parsed.flags.answers) {
     return parseAnswersFlag(parsed.flags.answers);
@@ -1346,8 +1535,61 @@ function collectAnswers(parsed) {
   return answers;
 }
 
-// src/commands/questions.ts
+// src/commands/questions/questions-constants.ts
 var ACTIONS3 = ["list", "show", "answer", "cancel"];
+
+// src/commands/questions/list-questions.ts
+async function listQuestions(sessionId, asJson) {
+  const result = expectShape(
+    await api(
+      sessionId ? path`/sessions/${sessionId}/questions` : "/questions"
+    ),
+    "GET /questions",
+    { items: is.array }
+  );
+  if (asJson) {
+    out.json(result);
+    return;
+  }
+  if (result.items.length === 0) {
+    out.line("Nothing waiting on you.");
+    return;
+  }
+  out.table(
+    result.items.map((batch) => [
+      out.cell(batch.id),
+      out.cell(batch.sessionId),
+      `${batch.questions.length} question(s)`,
+      out.cell(batch.sessionTitle)
+    ])
+  );
+}
+
+// src/commands/batch/print-batch-question.ts
+function printBatchQuestion(question) {
+  out.line();
+  if (question.header) {
+    out.line(out.paint(out.cell(question.header), "dim"));
+  }
+  out.line(
+    `${out.paint(out.cell(question.id), "dim")} ${out.safe(question.body)}`
+  );
+  if (question.image) {
+    out.line(out.paint(`    (image) ${out.cell(question.image)}`, "dim"));
+  }
+  for (const option of question.options) {
+    const recommended = option.id === question.recommendedOptionId;
+    const label = option.label ? out.cell(option.label) : option.image ? out.paint(`(image) ${out.cell(option.image)}`, "dim") : out.paint("(no label)", "dim");
+    out.line(
+      `    ${out.cell(option.id)}) ${label}${recommended ? out.paint("  \u2190 recommended", "green") : ""}`
+    );
+  }
+  if (question.allowFreeText) {
+    out.line(out.paint("    free text accepted", "dim"));
+  }
+}
+
+// src/commands/batch/print-batch.ts
 function printBatch(batch) {
   out.line(
     `${out.paint(out.cell(batch.sessionTitle), "bold")}  ${out.paint(`round ${batch.round}`, "dim")}`
@@ -1359,56 +1601,17 @@ function printBatch(batch) {
     )
   );
   for (const question of batch.questions) {
-    out.line();
-    if (question.header) {
-      out.line(out.paint(out.cell(question.header), "dim"));
-    }
-    out.line(
-      `${out.paint(out.cell(question.id), "dim")} ${out.safe(question.body)}`
-    );
-    if (question.image) {
-      out.line(out.paint(`    (image) ${out.cell(question.image)}`, "dim"));
-    }
-    for (const option of question.options) {
-      const recommended = option.id === question.recommendedOptionId;
-      const label = option.label ? out.cell(option.label) : option.image ? out.paint(`(image) ${out.cell(option.image)}`, "dim") : out.paint("(no label)", "dim");
-      out.line(
-        `    ${out.cell(option.id)}) ${label}${recommended ? out.paint("  \u2190 recommended", "green") : ""}`
-      );
-    }
-    if (question.allowFreeText) {
-      out.line(out.paint("    free text accepted", "dim"));
-    }
+    printBatchQuestion(question);
   }
 }
+
+// src/commands/command/questions-command.ts
 async function questionsCommand(parsed) {
   const action = args.action(parsed, "questions", ACTIONS3, "list");
   const asJson = parsed.booleans.has("json");
   if (action === "list") {
     args.expect(parsed, { flags: ["session"], positional: 1 });
-    const session = parsed.flags.session;
-    const result2 = expectShape(
-      await api(session ? path`/sessions/${session}/questions` : "/questions"),
-      "GET /questions",
-      { items: is.array }
-    );
-    if (asJson) {
-      out.json(result2);
-      return;
-    }
-    if (result2.items.length === 0) {
-      out.line("Nothing waiting on you.");
-      return;
-    }
-    out.table(
-      result2.items.map((batch) => [
-        out.cell(batch.id),
-        out.cell(batch.sessionId),
-        `${batch.questions.length} question(s)`,
-        out.cell(batch.sessionTitle)
-      ])
-    );
-    return;
+    return await listQuestions(parsed.flags.session, asJson);
   }
   args.expect(parsed, {
     positional: 2,
@@ -1459,11 +1662,17 @@ async function questionsCommand(parsed) {
   );
 }
 
-// src/lib/format-event.ts
+// src/lib/follow/follow-constants.ts
+var POLL_SECONDS = 3;
+var PAGE_SIZE = 200;
+
+// src/lib/truncate/truncate.ts
 function truncate(text, max = 2e3) {
   const trimmed = out.safe(text).trim();
   return trimmed.length > max ? `${trimmed.slice(0, max)}\u2026` : trimmed;
 }
+
+// src/lib/event/format-event.ts
 function formatEvent(event) {
   const part = event.part;
   switch (part.kind) {
@@ -1515,14 +1724,33 @@ function formatEvent(event) {
   }
 }
 
-// src/lib/follow.ts
+// src/lib/session/consume-session-events.ts
+function consumeSessionEvents(events, cursor, quiet) {
+  for (const event of events) {
+    cursor = Math.max(cursor, event.sequence);
+    if (quiet) {
+      continue;
+    }
+    const line = formatEvent(event);
+    if (line) {
+      out.line(line);
+    }
+  }
+  return cursor;
+}
+
+// src/lib/terminal/terminal-constants.ts
 var TERMINAL = /* @__PURE__ */ new Set(["completed", "failed", "killed", "abstained"]);
+
+// src/lib/blocked/blocked-constants.ts
 var BLOCKED = /* @__PURE__ */ new Set(["waiting_human", "awaiting_approval"]);
-var POLL_SECONDS = 3;
-var PAGE_SIZE = 200;
+
+// src/lib/sleep/sleep.ts
 function sleep2(seconds) {
   return new Promise((resolve) => setTimeout(resolve, seconds * 1e3));
 }
+
+// src/lib/session/follow-session.ts
 async function followSession(sessionId, options = {}) {
   let cursor = options.after ?? 0;
   for (; ; ) {
@@ -1533,16 +1761,7 @@ async function followSession(sessionId, options = {}) {
       "GET /sessions/{id}/events",
       { items: is.array }
     );
-    for (const event of page.items) {
-      cursor = Math.max(cursor, event.sequence);
-      if (options.quiet) {
-        continue;
-      }
-      const line = formatEvent(event);
-      if (line) {
-        out.line(line);
-      }
-    }
+    cursor = consumeSessionEvents(page.items, cursor, options.quiet);
     if (page.nextCursor !== null) {
       cursor = Math.max(cursor, page.nextCursor);
     }
@@ -1557,11 +1776,8 @@ async function followSession(sessionId, options = {}) {
   }
 }
 
-// src/lib/print-session.ts
-function printSession(session) {
-  out.line(
-    `${out.paint(out.cell(session.title), "bold")}  ${out.status(session.status)}`
-  );
+// src/lib/session/build-session-detail-rows.ts
+function buildSessionDetailRows(session) {
   const rows = [["id", out.cell(session.id)]];
   if (session.statusReason) {
     rows.push(["reason", out.cell(session.statusReason)]);
@@ -1592,23 +1808,39 @@ function printSession(session) {
       rows.push([out.cell(deliverable.type), out.cell(deliverable.url)]);
     }
   }
-  out.table(rows.map(([label, value]) => [out.paint(label, "dim"), value]));
-  const steps = session.playbook?.steps ?? [];
-  if (steps.length > 0) {
-    out.line();
-    for (const step of steps) {
-      const done = step.todos.filter(
-        (todo) => todo.status === "completed"
-      ).length;
-      const marker = done === step.todos.length && step.todos.length > 0 ? "\u2713" : "\xB7";
-      out.line(
-        `  ${marker} ${out.cell(step.title)} ${out.paint(`${done}/${step.todos.length}`, "dim")}`
-      );
-    }
+  return rows;
+}
+
+// src/lib/session/print-playbook-steps.ts
+function printPlaybookSteps(steps) {
+  if (steps.length === 0) {
+    return;
+  }
+  out.line();
+  for (const step of steps) {
+    const done = step.todos.filter(
+      (todo) => todo.status === "completed"
+    ).length;
+    const marker = done === step.todos.length && step.todos.length > 0 ? "\u2713" : "\xB7";
+    out.line(
+      `  ${marker} ${out.cell(step.title)} ${out.paint(`${done}/${step.todos.length}`, "dim")}`
+    );
   }
 }
 
-// src/lib/session-outcome.ts
+// src/lib/session/print-session.ts
+function printSession(session) {
+  out.line(
+    `${out.paint(out.cell(session.title), "bold")}  ${out.status(session.status)}`
+  );
+  const rows = buildSessionDetailRows(session);
+  out.table(
+    rows.map(([label, value]) => [out.paint(label ?? "", "dim"), value ?? ""])
+  );
+  printPlaybookSteps(session.playbook?.steps ?? []);
+}
+
+// src/lib/session/session-outcome.ts
 function sessionOutcome(session) {
   switch (session.status) {
     case "completed":
@@ -1637,7 +1869,26 @@ function sessionOutcome(session) {
   }
 }
 
-// src/commands/run.ts
+// src/lib/session/write-followed-session-outcome.ts
+function writeFollowedSessionOutcome(session, asJson) {
+  const outcome = sessionOutcome(session);
+  if (asJson) {
+    if (!outcome) out.json(session);
+  } else {
+    out.line();
+    printSession(session);
+  }
+  if (outcome) throw outcome;
+}
+
+// src/commands/harnesses/harnesses-constants.ts
+var HARNESSES = [
+  "claude-code",
+  "codex",
+  "cursor"
+];
+
+// src/commands/task/task-types-constants.ts
 var TASK_TYPES = [
   "implement",
   "new-project",
@@ -1645,11 +1896,24 @@ var TASK_TYPES = [
   "draft",
   "orchestrator"
 ];
-var HARNESSES = [
-  "claude-code",
-  "codex",
-  "cursor"
-];
+
+// src/commands/command/create-run-input.ts
+function createRunInput(parsed, prompt) {
+  const taskType = args.choice(parsed, "task-type", TASK_TYPES);
+  const harness = args.choice(parsed, "harness", HARNESSES);
+  return {
+    prompt,
+    ...parsed.flags.title ? { title: parsed.flags.title } : {},
+    ...taskType ? { taskType } : {},
+    ...parsed.flags.model ? { modelSelection: parsed.flags.model } : {},
+    ...harness ? { harnessPin: harness } : {},
+    ...parsed.flags.repo ? { repoFullName: parsed.flags.repo } : {},
+    ...parsed.flags.branch ? { branch: parsed.flags.branch } : {},
+    ...parsed.repeated.skill ? { pinnedSkillIds: parsed.repeated.skill } : {}
+  };
+}
+
+// src/commands/command/run-command.ts
 async function runCommand(parsed) {
   args.expect(parsed, {
     flags: [
@@ -1666,18 +1930,7 @@ async function runCommand(parsed) {
   });
   const prompt = args.required(parsed, 0, "prompt");
   const asJson = parsed.booleans.has("json");
-  const taskType = args.choice(parsed, "task-type", TASK_TYPES);
-  const harness = args.choice(parsed, "harness", HARNESSES);
-  const body = {
-    prompt,
-    ...parsed.flags.title ? { title: parsed.flags.title } : {},
-    ...taskType ? { taskType } : {},
-    ...parsed.flags.model ? { modelSelection: parsed.flags.model } : {},
-    ...harness ? { harnessPin: harness } : {},
-    ...parsed.flags.repo ? { repoFullName: parsed.flags.repo } : {},
-    ...parsed.flags.branch ? { branch: parsed.flags.branch } : {},
-    ...parsed.repeated.skill ? { pinnedSkillIds: parsed.repeated.skill } : {}
-  };
+  const body = createRunInput(parsed, prompt);
   const session = expectShape(
     await api("/sessions", { method: "POST", body }),
     "POST /sessions",
@@ -1699,21 +1952,10 @@ async function runCommand(parsed) {
     out.line();
   }
   const final = await followSession(session.id, { quiet });
-  const outcome = sessionOutcome(final);
-  if (asJson) {
-    if (!outcome) {
-      out.json(final);
-    }
-  } else {
-    out.line();
-    printSession(final);
-  }
-  if (outcome) {
-    throw outcome;
-  }
+  writeFollowedSessionOutcome(final, asJson);
 }
 
-// src/commands/sessions.ts
+// src/commands/sessions/sessions-constants.ts
 var ACTIONS4 = [
   "list",
   "get",
@@ -1742,9 +1984,8 @@ var SESSION_FIELDS = {
   repos: is.array,
   deliverables: is.array
 };
-function detail(payload, endpoint) {
-  return expectShape(payload, endpoint, SESSION_FIELDS);
-}
+
+// src/commands/sessions/list-sessions.ts
 async function listSessions(parsed) {
   args.expect(parsed, {
     flags: ["status", "repo", "search", "page", "limit"],
@@ -1791,6 +2032,39 @@ async function listSessions(parsed) {
     ])
   );
 }
+
+// src/commands/session/send-session-message.ts
+async function sendSessionMessage(parsed, asJson) {
+  args.expect(parsed, { positional: 3 });
+  const sessionId = args.required(parsed, 1, "sessionId");
+  const message = args.required(parsed, 2, "message");
+  const result = expectShape(
+    await api(path`/sessions/${sessionId}/messages`, {
+      method: "POST",
+      body: { message }
+    }),
+    "POST /sessions/{id}/messages",
+    { delivery: is.string }
+  );
+  if (asJson) {
+    out.json(result);
+    return;
+  }
+  out.line(
+    result.delivery === "interrupt" ? "Delivered to the running agent." : "Queued \u2014 the agent picks it up at the end of its turn."
+  );
+}
+
+// src/commands/show/follow-session-logs.ts
+async function followSessionLogs(parsed, sessionId, after, asJson) {
+  const session = await followSession(sessionId, {
+    quiet: asJson || parsed.booleans.has("quiet"),
+    ...after !== void 0 ? { after } : {}
+  });
+  writeFollowedSessionOutcome(session, asJson);
+}
+
+// src/commands/show/show-logs.ts
 async function showLogs(parsed) {
   args.expect(parsed, {
     flags: ["after", "limit"],
@@ -1801,22 +2075,7 @@ async function showLogs(parsed) {
   const asJson = parsed.booleans.has("json");
   const after = args.integer(parsed, "after", { min: 0 });
   if (parsed.booleans.has("follow")) {
-    const session = await followSession(sessionId, {
-      quiet: asJson || parsed.booleans.has("quiet"),
-      ...after !== void 0 ? { after } : {}
-    });
-    const outcome = sessionOutcome(session);
-    if (asJson) {
-      if (!outcome) {
-        out.json(session);
-      }
-    } else {
-      out.line();
-      printSession(session);
-    }
-    if (outcome) {
-      throw outcome;
-    }
+    await followSessionLogs(parsed, sessionId, after, asJson);
     return;
   }
   const page = expectShape(
@@ -1849,36 +2108,41 @@ async function showLogs(parsed) {
     );
   }
 }
-async function sessionsCommand(parsed) {
-  const action = args.action(parsed, "sessions", ACTIONS4, "list");
-  const asJson = parsed.booleans.has("json");
-  if (action === "list") {
-    return await listSessions(parsed);
-  }
-  if (action === "logs") {
-    return await showLogs(parsed);
-  }
-  if (action === "send") {
-    args.expect(parsed, { positional: 3 });
-    const sessionId2 = args.required(parsed, 1, "sessionId");
-    const message = args.required(parsed, 2, "message");
-    const result = expectShape(
-      await api(path`/sessions/${sessionId2}/messages`, {
-        method: "POST",
-        body: { message }
-      }),
-      "POST /sessions/{id}/messages",
-      { delivery: is.string }
-    );
-    if (asJson) {
-      out.json(result);
-      return;
-    }
-    out.line(
-      result.delivery === "interrupt" ? "Delivered to the running agent." : "Queued \u2014 the agent picks it up at the end of its turn."
-    );
+
+// src/commands/sessions/session-actions.ts
+var sessionActions = {
+  list: (parsed) => listSessions(parsed),
+  logs: (parsed) => showLogs(parsed),
+  send: sendSessionMessage
+};
+
+// src/commands/detail/detail.ts
+function detail(payload, endpoint) {
+  return expectShape(payload, endpoint, SESSION_FIELDS);
+}
+
+// src/commands/command/run-session-control-action.ts
+async function runSessionControlAction(parsed, action, sessionId, asJson) {
+  const controlPath = CONTROL_PATHS[action];
+  if (controlPath === void 0) {
+    throw new CliError(`Unknown session action: ${action}`, 2);
+  }
+  const session = detail(
+    await api(path`/sessions/${sessionId}/${controlPath}`, {
+      method: "POST",
+      body: action === "kill" && parsed.flags.reason ? { reason: parsed.flags.reason } : {}
+    }),
+    `POST /sessions/{id}/${controlPath}`
+  );
+  if (asJson) {
+    out.json(session);
     return;
   }
+  printSession(session);
+}
+
+// src/commands/command/run-session-operation.ts
+async function runSessionOperation(parsed, action, asJson) {
   args.expect(parsed, {
     positional: 2,
     ...action === "kill" ? { flags: ["reason"] } : {}
@@ -1897,19 +2161,7 @@ async function sessionsCommand(parsed) {
     return;
   }
   if (Object.hasOwn(CONTROL_PATHS, action)) {
-    const controlPath = CONTROL_PATHS[action];
-    const session = detail(
-      await api(path`/sessions/${sessionId}/${controlPath}`, {
-        method: "POST",
-        body: action === "kill" && parsed.flags.reason ? { reason: parsed.flags.reason } : {}
-      }),
-      `POST /sessions/{id}/${controlPath}`
-    );
-    if (asJson) {
-      out.json(session);
-      return;
-    }
-    printSession(session);
+    await runSessionControlAction(parsed, action, sessionId, asJson);
     return;
   }
   if (action === "checks") {
@@ -1936,7 +2188,18 @@ async function sessionsCommand(parsed) {
   );
 }
 
-// src/commands/whoami.ts
+// src/commands/command/sessions-command.ts
+async function sessionsCommand(parsed) {
+  const action = args.action(parsed, "sessions", ACTIONS4, "list");
+  const asJson = parsed.booleans.has("json");
+  const dedicated = sessionActions[action];
+  if (dedicated) {
+    return await dedicated(parsed, asJson);
+  }
+  await runSessionOperation(parsed, action, asJson);
+}
+
+// src/commands/command/whoami-command.ts
 async function whoamiCommand(parsed) {
   args.expect(parsed, {});
   const identity = expectShape(
@@ -1970,21 +2233,15 @@ async function whoamiCommand(parsed) {
   ]);
 }
 
-// src/lib/wants-json.ts
-function wantsJson(argv) {
-  for (const token of argv) {
-    if (token === "--") {
-      return false;
-    }
-    if (token === "--json") {
-      return true;
-    }
-  }
-  return false;
-}
+// src/catalog-topics-constants.ts
+var CATALOG_TOPICS = /* @__PURE__ */ new Set([
+  "repos",
+  "branches",
+  "models",
+  "skills"
+]);
 
-// src/index.ts
-var CATALOG_TOPICS = /* @__PURE__ */ new Set(["repos", "branches", "models", "skills"]);
+// src/dispatch.ts
 async function dispatch(command, argv) {
   const parsed = args.parse(argv);
   if (parsed.booleans.has("help")) {
@@ -2016,6 +2273,8 @@ async function dispatch(command, argv) {
       throw new CliError(`Unknown command "${command}".`, 2);
   }
 }
+
+// src/main.ts
 async function main() {
   const argv = process.argv.slice(2);
   out.setJson(wantsJson(argv));
@@ -2035,9 +2294,19 @@ async function main() {
   }
   await dispatch(command, rest);
 }
-main().catch((error) => {
-  const failure = error instanceof CliError ? error : new CliError(error instanceof Error ? error.message : String(error));
-  out.failure(failure);
-  process.exit(failure.exitCode);
-});
+
+// src/cli-entry.ts
+async function cliEntry() {
+  try {
+    await main();
+  } catch (error) {
+    const failure = error instanceof CliError ? error : new CliError(error instanceof Error ? error.message : String(error));
+    out.failure(failure);
+    process.exit(failure.exitCode);
+  }
+}
+void cliEntry();
+export {
+  cliEntry
+};
 //# sourceMappingURL=index.js.map