ultrahope 0.1.2 → 0.1.4

package/dist/index.js

@@ -1,10 +1,7 @@
 #!/usr/bin/env node
 
-// index.ts
-import { createRequire } from "module";
-
 // commands/jj.ts
-import { execSync as execSync2, spawnSync } from "child_process";
+import { execFileSync, execSync as execSync2, spawnSync } from "child_process";
 
 // lib/api-client.ts
 import createClient from "openapi-fetch";
@@ -39,11 +36,33 @@ function log(message, data) {
 // lib/api-client.ts
 var API_BASE_URL = process.env.ULTRAHOPE_API_URL ?? "https://ultrahope.dev";
 var InsufficientBalanceError = class extends Error {
-  constructor(balance) {
+  constructor(balance, plan = "free", hint, actions) {
     super("Token balance exhausted");
     this.balance = balance;
+    this.plan = plan;
+    this.hint = hint;
+    this.actions = actions;
     this.name = "InsufficientBalanceError";
   }
+  formatMessage() {
+    const lines = [];
+    if (this.plan === "pro") {
+      lines.push(
+        "Error: Your usage credit has been exhausted. Purchase additional credits to continue."
+      );
+      if (this.actions?.buyCredits) {
+        lines.push(`  Buy credits: ${this.actions.buyCredits}`);
+      }
+    } else {
+      lines.push(
+        "Error: Your free credit has been exhausted. Upgrade to Pro for unlimited requests with $5 included credit."
+      );
+      if (this.actions?.upgrade) {
+        lines.push(`  Upgrade: ${this.actions.upgrade}`);
+      }
+    }
+    return lines.join("\n");
+  }
 };
 var DailyLimitExceededError = class extends Error {
   constructor(count, limit, resetsAt) {
@@ -60,6 +79,14 @@ var UnauthorizedError = class extends Error {
     this.name = "UnauthorizedError";
   }
 };
+var InvalidModelError = class extends Error {
+  constructor(model, allowedModels, message) {
+    super(message ?? `Model '${model}' is not supported.`);
+    this.model = model;
+    this.allowedModels = allowedModels;
+    this.name = "InvalidModelError";
+  }
+};
 async function getErrorText(response, error) {
   if (error) {
     try {
@@ -102,18 +129,34 @@ function parseSseEvents(buffer) {
   return { events, remainder };
 }
 function handle402Error(error) {
-  const errorBalance = error?.balance;
-  if (typeof errorBalance === "number") {
+  const payload = error;
+  if (typeof payload?.balance === "number") {
     log("generate error (402 insufficient_balance)", error);
-    throw new InsufficientBalanceError(errorBalance);
+    const plan = payload.plan === "pro" || payload.plan === "free" ? payload.plan : "free";
+    throw new InsufficientBalanceError(
+      payload.balance,
+      plan,
+      payload.hint,
+      payload.actions
+    );
   }
-  const payload = error;
   const count = typeof payload?.count === "number" ? payload.count : 0;
   const limit = typeof payload?.limit === "number" ? payload.limit : 0;
   const resetsAt = payload?.resetsAt ?? "";
   log("generate error (402 daily_limit)", error);
   throw new DailyLimitExceededError(count, limit, resetsAt);
 }
+function throwInvalidModelError(error) {
+  const payload = error;
+  const message = payload?.message ?? "Model is not supported.";
+  const modelMatch = message.match(/Model '([^']+)' is not supported\./);
+  const model = payload?.model ?? modelMatch?.[1] ?? "unknown";
+  const allowedModels = Array.isArray(payload?.allowedModels) ? payload.allowedModels.filter(
+    (value) => typeof value === "string"
+  ) : [];
+  log("generate error (400 invalid_model)", error);
+  throw new InvalidModelError(model, allowedModels, message);
+}
 function createApiClient(token) {
   const headers = {
     "Content-Type": "application/json"
@@ -150,6 +193,15 @@ function createApiClient(token) {
         }
         handle402Error(errorPayload);
       }
+      if (res.status === 400) {
+        let errorPayload;
+        try {
+          errorPayload = await res.json();
+        } catch {
+          errorPayload = await getErrorText(res, null);
+        }
+        throwInvalidModelError(errorPayload);
+      }
       if (!res.ok) {
         const text = await getErrorText(res, null);
         log("streamCommitMessage error", {
@@ -210,12 +262,8 @@ function createApiClient(token) {
         throw new UnauthorizedError();
       }
       if (response.status === 402) {
-        const payload = error;
-        const count = typeof payload?.count === "number" ? payload.count : 0;
-        const limit = typeof payload?.limit === "number" ? payload.limit : 0;
-        const resetsAt = payload?.resetsAt ?? "";
         log("command_execution error (402)", error);
-        throw new DailyLimitExceededError(count, limit, resetsAt);
+        handle402Error(error);
       }
       if (!response.ok) {
         const text = await getErrorText(response, error);
@@ -244,6 +292,9 @@ function createApiClient(token) {
       if (response.status === 402) {
         handle402Error(error);
       }
+      if (response.status === 400) {
+        throwInvalidModelError(error);
+      }
       if (!response.ok) {
         const text = await getErrorText(response, error);
         log("generateCommitMessage error", { status: response.status, text });
@@ -295,6 +346,9 @@ function createApiClient(token) {
       if (response.status === 402) {
         handle402Error(error);
       }
+      if (response.status === 400) {
+        throwInvalidModelError(error);
+      }
       if (!response.ok) {
         const text = await getErrorText(response, error);
         log("generatePrTitleBody error", { status: response.status, text });
@@ -319,6 +373,9 @@ function createApiClient(token) {
       if (response.status === 402) {
         handle402Error(error);
       }
+      if (response.status === 400) {
+        throwInvalidModelError(error);
+      }
       if (!response.ok) {
         const text = await getErrorText(response, error);
         log("generatePrIntent error", { status: response.status, text });
@@ -568,7 +625,7 @@ async function showDailyLimitPrompt(info) {
   }
 }
 function promptChoice() {
-  return new Promise((resolve) => {
+  return new Promise((resolve3) => {
     const fd = openSync("/dev/tty", "r");
     const ttyInput = new tty.ReadStream(fd);
     const rl = readline.createInterface({
@@ -591,17 +648,17 @@ function promptChoice() {
       if (!key && !str) return;
       if (str === "q" || str === "Q" || key?.name === "q" || key?.name === "c" && key.ctrl || key?.name === "escape") {
         cleanup();
-        resolve("q");
+        resolve3("q");
         return;
       }
       if (str === "1" || key?.name === "1" || key?.sequence === "1") {
         cleanup();
-        resolve("1");
+        resolve3("1");
         return;
       }
       if (str === "2" || key?.name === "2" || key?.sequence === "2") {
         cleanup();
-        resolve("2");
+        resolve3("2");
         return;
       }
     };
@@ -618,7 +675,7 @@ function handleRetryLater() {
   );
   console.log(`  ${ui.link("ultrahope jj describe")}`);
   console.log("");
-  return new Promise((resolve) => {
+  return new Promise((resolve3) => {
     const fd = openSync("/dev/tty", "r");
     const ttyInput = new tty.ReadStream(fd);
     const rl = readline.createInterface({
@@ -638,7 +695,7 @@ function handleRetryLater() {
       if (!key && !str) return;
       if (str === "\r" || str === "\n" || str === "q" || str === "Q" || key?.name === "return" || key?.name === "q" || key?.name === "c" && key.ctrl) {
         cleanup();
-        resolve();
+        resolve3();
       }
     };
     ttyInput.on("keypress", handleKeypress);
@@ -702,11 +759,374 @@ async function handleCommandExecutionError(error, options) {
     });
     process.exit(1);
   }
+  if (error instanceof InsufficientBalanceError) {
+    console.error(error.formatMessage());
+    process.exit(1);
+  }
   const message = error instanceof Error ? error.message : String(error);
   console.error(`Error: Failed to start command execution. ${message}`);
   process.exit(1);
 }
 
+// lib/config.ts
+import * as fs2 from "fs";
+import * as os2 from "os";
+import * as path2 from "path";
+import { parse } from "smol-toml";
+
+// ../shared/async-race.ts
+async function* raceAsyncIterators({
+  iterators,
+  signal,
+  onError
+}) {
+  if (iterators.length === 0) {
+    return;
+  }
+  if (signal?.aborted) {
+    return;
+  }
+  const abortPromise = signal ? new Promise((resolve3) => {
+    signal.addEventListener("abort", () => resolve3(null), { once: true });
+  }) : null;
+  const pending = /* @__PURE__ */ new Map();
+  const startNext = (index) => {
+    const iterator = iterators[index];
+    if (!iterator) {
+      return;
+    }
+    pending.set(
+      index,
+      iterator.next().then(
+        (result) => ({ kind: "result", index, result }),
+        (error) => ({ kind: "error", index, error })
+      )
+    );
+  };
+  const throwOrContinue = (error, index) => {
+    if (!onError) {
+      throw error;
+    }
+    const decision = onError(index, error);
+    if (decision === "throw") {
+      throw error;
+    }
+  };
+  try {
+    for (let index = 0; index < iterators.length; index++) {
+      startNext(index);
+    }
+    while (pending.size > 0) {
+      const winner = abortPromise ? await Promise.race([
+        ...pending.values(),
+        abortPromise.then(() => null)
+      ]) : await Promise.race([...pending.values()]);
+      if (winner === null) {
+        return;
+      }
+      const { index } = winner;
+      pending.delete(index);
+      if (winner.kind === "error") {
+        throwOrContinue(winner.error, winner.index);
+        continue;
+      }
+      const { result } = winner;
+      if (!result.done) {
+        startNext(index);
+        yield { index, result };
+      }
+    }
+  } finally {
+    for (const iterator of iterators) {
+      try {
+        await iterator.return?.();
+      } catch {
+      }
+    }
+    for (const promise of pending.values()) {
+      promise.catch(() => void 0);
+    }
+  }
+}
+
+// lib/vcs-message-generator.ts
+var DEFAULT_MODELS = [
+  // "mistral/ministral-3b",
+  // "cerebras/qwen-3-235b",
+  // "openai/gpt-5.1",
+  "mistral/ministral-3b",
+  "xai/grok-code-fast-1"
+];
+var isAbortError = (error) => error instanceof Error && error.name === "AbortError";
+var isInvalidCliSessionIdError = (error) => error instanceof Error && error.message.includes("Invalid cliSessionId");
+var delay = (ms) => new Promise((resolve3) => setTimeout(resolve3, ms));
+async function* generateCommitMessages(options) {
+  const {
+    diff,
+    models,
+    signal,
+    cliSessionId,
+    commandExecutionPromise,
+    useStream = false,
+    streamCaptureRecorder
+  } = options;
+  const resolvedCliSessionId = cliSessionId;
+  if (!resolvedCliSessionId) {
+    throw new Error("Missing cliSessionId for generate request.");
+  }
+  const requiredCliSessionId = resolvedCliSessionId;
+  const captureGenerationId = streamCaptureRecorder?.startGeneration({
+    cliSessionId: requiredCliSessionId,
+    models
+  });
+  const token = await getToken();
+  if (!token) {
+    console.error("Error: Not authenticated. Run `ultrahope login` first.");
+    process.exit(1);
+  }
+  const api = createApiClient(token);
+  const generateWithRetry = async function* (payload) {
+    const maxAttempts = 3;
+    for (let attempt = 0; attempt < maxAttempts; attempt++) {
+      const attemptNumber = attempt + 1;
+      try {
+        for await (const event of api.streamCommitMessage(payload, {
+          signal
+        })) {
+          if (captureGenerationId != null) {
+            streamCaptureRecorder?.recordEvent(captureGenerationId, {
+              model: payload.model,
+              attempt: attemptNumber,
+              event
+            });
+          }
+          log("generate", event);
+          yield event;
+        }
+        return;
+      } catch (error) {
+        if (signal?.aborted || isAbortError(error)) throw error;
+        if (isInvalidCliSessionIdError(error)) {
+          if (commandExecutionPromise) {
+            try {
+              await commandExecutionPromise;
+              continue;
+            } catch {
+              const abortError = new Error("Aborted");
+              abortError.name = "AbortError";
+              throw abortError;
+            }
+          }
+          if (attempt < maxAttempts - 1) {
+            await delay(80 * (attempt + 1));
+            continue;
+          }
+        }
+        throw error;
+      }
+    }
+    throw new Error("Failed to generate after retries.");
+  };
+  async function* generateForModel(model, slotIndex) {
+    try {
+      if (signal?.aborted) return;
+      let lastCommitMessage = "";
+      let providerMetadata;
+      for await (const event of generateWithRetry({
+        cliSessionId: requiredCliSessionId,
+        input: diff,
+        model,
+        guide: options.guide
+      })) {
+        if (event.type === "commit-message") {
+          lastCommitMessage = event.commitMessage;
+          if (useStream) {
+            yield {
+              content: lastCommitMessage,
+              slotId: model,
+              model,
+              isPartial: true,
+              slotIndex
+            };
+          }
+        } else if (event.type === "provider-metadata") {
+          providerMetadata = event.providerMetadata;
+        } else if (event.type === "error") {
+          throw new Error(event.message);
+        }
+      }
+      if (lastCommitMessage) {
+        const { generationId, cost } = extractGatewayMetadata(providerMetadata);
+        yield {
+          content: lastCommitMessage,
+          slotId: model,
+          model,
+          cost,
+          generationId,
+          ...useStream ? { isPartial: false } : {},
+          slotIndex
+        };
+      }
+    } catch (error) {
+      if (signal?.aborted || isAbortError(error)) return;
+      if (error instanceof InvalidModelError) throw error;
+      if (error instanceof InsufficientBalanceError) throw error;
+      if (isInvalidCliSessionIdError(error)) throw error;
+    }
+  }
+  const iterators = models.map(
+    (model, index) => generateForModel(model, index)[Symbol.asyncIterator]()
+  );
+  try {
+    for await (const { result } of raceAsyncIterators({
+      iterators,
+      signal,
+      onError(index, error) {
+        if (isAbortError(error) || signal?.aborted) {
+          return "continue";
+        }
+        void index;
+        return "throw";
+      }
+    })) {
+      yield result.value;
+    }
+  } catch (error) {
+    if (error instanceof InvalidModelError) {
+      throw error;
+    }
+    if (error instanceof InsufficientBalanceError) {
+      console.error(error.formatMessage());
+      process.exit(1);
+    }
+    throw error;
+  } finally {
+    if (captureGenerationId != null) {
+      streamCaptureRecorder?.finishGeneration(captureGenerationId);
+    }
+  }
+}
+
+// lib/config.ts
+var PROJECT_CONFIG_FILENAMES = [".ultrahope.toml", "ultrahope.toml"];
+function fail(message) {
+  console.error(`Error: ${message}`);
+  process.exit(1);
+}
+function validateModels(models, sourcePath) {
+  if (!Array.isArray(models)) {
+    fail(
+      `Invalid config in ${sourcePath}: models must be an array of strings.`
+    );
+  }
+  if (models.length === 0) {
+    fail(`Invalid config in ${sourcePath}: models must not be empty.`);
+  }
+  const normalized = models.map((model, index) => {
+    if (typeof model !== "string") {
+      fail(
+        `Invalid config in ${sourcePath}: models[${index}] must be a string.`
+      );
+    }
+    const trimmed = model.trim();
+    if (!trimmed) {
+      fail(
+        `Invalid config in ${sourcePath}: models[${index}] must not be empty.`
+      );
+    }
+    return trimmed;
+  });
+  return normalized;
+}
+function parseModelsArg(value) {
+  const rawModels = value.split(",");
+  const models = rawModels.map((m) => m.trim());
+  if (models.length === 0 || models.every((m) => m.length === 0)) {
+    fail("--models requires at least one non-empty model.");
+  }
+  const emptyIndex = models.findIndex((m) => m.length === 0);
+  if (emptyIndex !== -1) {
+    fail(`--models contains an empty value at position ${emptyIndex + 1}.`);
+  }
+  return models;
+}
+function getGlobalConfigPath() {
+  const configDir = process.env.XDG_CONFIG_HOME ?? path2.join(os2.homedir(), ".config");
+  return path2.join(configDir, "ultrahope", "config.toml");
+}
+function findNearestProjectConfig(cwd) {
+  let current = path2.resolve(cwd);
+  while (true) {
+    for (const filename of PROJECT_CONFIG_FILENAMES) {
+      const candidate = path2.join(current, filename);
+      if (fs2.existsSync(candidate)) {
+        return candidate;
+      }
+    }
+    const parent = path2.dirname(current);
+    if (parent === current) {
+      return null;
+    }
+    current = parent;
+  }
+}
+function readConfigModels(configPath) {
+  let raw = "";
+  try {
+    raw = fs2.readFileSync(configPath, "utf-8");
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    fail(`Failed to read config file ${configPath}: ${message}`);
+  }
+  let parsed;
+  try {
+    parsed = parse(raw);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    fail(`Failed to parse TOML config ${configPath}: ${message}`);
+  }
+  if (parsed.models === void 0) {
+    return void 0;
+  }
+  return validateModels(parsed.models, configPath);
+}
+function resolveModels(cliModels) {
+  if (cliModels && cliModels.length > 0) {
+    return cliModels;
+  }
+  const projectConfigPath = findNearestProjectConfig(process.cwd());
+  if (projectConfigPath) {
+    const projectModels = readConfigModels(projectConfigPath);
+    if (projectModels) {
+      return projectModels;
+    }
+  }
+  const globalConfigPath = getGlobalConfigPath();
+  if (fs2.existsSync(globalConfigPath)) {
+    const globalModels = readConfigModels(globalConfigPath);
+    if (globalModels) {
+      return globalModels;
+    }
+  }
+  return DEFAULT_MODELS;
+}
+async function ensureGlobalConfigFile() {
+  const configPath = getGlobalConfigPath();
+  if (fs2.existsSync(configPath)) {
+    return;
+  }
+  const dir = path2.dirname(configPath);
+  await fs2.promises.mkdir(dir, { recursive: true });
+  const content = `# Ultrahope CLI configuration
+# https://github.com/toyamarinyon/ultrahope
+
+# Models to use for generation (each model produces one candidate)
+# See available models: https://ultrahope.dev/models
+models = ["mistral/ministral-3b", "xai/grok-code-fast-1"]
+`;
+  await fs2.promises.writeFile(configPath, content, { mode: 420, flag: "wx" });
+}
+
 // lib/diff-stats.ts
 import { execSync } from "child_process";
 function getJjDiffStats(revision) {
@@ -745,39 +1165,85 @@ import {
   constants as constants2,
   mkdtempSync,
   openSync as openSync2,
-  readFileSync,
+  readFileSync as readFileSync2,
   unlinkSync,
   writeFileSync
 } from "fs";
 import { tmpdir } from "os";
-import { join as join3 } from "path";
+import { join as join4 } from "path";
 import * as readline3 from "readline";
 import * as tty2 from "tty";
 
-// lib/renderer.ts
-import * as readline2 from "readline";
-var SPINNER_FRAMES = [
-  "\u280B",
-  "\u2819",
-  "\u2839",
-  "\u2838",
-  "\u283C",
-  "\u2834",
-  "\u2826",
-  "\u2827",
-  "\u2807",
-  "\u280F"
-];
-function isTTY(output) {
-  return output.isTTY === true;
+// ../shared/terminal-selector-helpers.ts
+function formatModelName(model) {
+  const parts = model.split("/");
+  return parts.length > 1 ? parts[1] : model;
 }
-function createRenderer(output) {
-  let pendingHeight = 0;
-  let committedHeight = 0;
-  const render = (content) => {
-    if (!isTTY(output)) {
-      output.write(content);
-      return;
+function formatCost(cost) {
+  return `$${cost.toFixed(7).replace(/0+$/, "").replace(/\.$/, "")}`;
+}
+function formatTotalCostLabel(cost) {
+  return `$${cost.toFixed(6)}`;
+}
+function getReadyCount(slots) {
+  return slots.filter((slot) => slot.status === "ready").length;
+}
+function getTotalCost(slots) {
+  return slots.reduce((sum, slot) => {
+    if (slot.status === "ready" && slot.candidate.cost != null) {
+      return sum + slot.candidate.cost;
+    }
+    return sum;
+  }, 0);
+}
+function getLatestQuota(slots) {
+  for (const slot of slots) {
+    if (slot.status === "ready" && slot.candidate.quota) {
+      return slot.candidate.quota;
+    }
+  }
+  return void 0;
+}
+function hasReadySlot(slots) {
+  return getReadyCount(slots) > 0;
+}
+function selectNearestReady(slots, startIndex, direction) {
+  for (let index = startIndex + direction; index >= 0 && index < slots.length; index += direction) {
+    if (slots[index]?.status === "ready") {
+      return index;
+    }
+  }
+  return startIndex;
+}
+function getSelectedCandidate(slots, selectedIndex) {
+  const slot = slots[selectedIndex];
+  return slot?.status === "ready" ? slot.candidate : void 0;
+}
+
+// lib/renderer.ts
+import * as readline2 from "readline";
+var SPINNER_FRAMES = [
+  "\u280B",
+  "\u2819",
+  "\u2839",
+  "\u2838",
+  "\u283C",
+  "\u2834",
+  "\u2826",
+  "\u2827",
+  "\u2807",
+  "\u280F"
+];
+function isTTY(output) {
+  return output.isTTY === true;
+}
+function createRenderer(output) {
+  let pendingHeight = 0;
+  let committedHeight = 0;
+  const render = (content) => {
+    if (!isTTY(output)) {
+      output.write(content);
+      return;
     }
     if (pendingHeight > 0) {
       readline2.moveCursor(output, 0, -pendingHeight);
@@ -813,47 +1279,6 @@ function createRenderer(output) {
 
 // lib/selector.ts
 var TTY_PATH = "/dev/tty";
-function formatModelName(model) {
-  const parts = model.split("/");
-  return parts.length > 1 ? parts[1] : model;
-}
-function formatCost(cost) {
-  return `$${cost.toFixed(7).replace(/0+$/, "").replace(/\.$/, "")}`;
-}
-function getReadyCount(slots) {
-  return slots.filter((s) => s.status === "ready").length;
-}
-function getTotalCost(slots) {
-  return slots.reduce((sum, slot) => {
-    if (slot.status === "ready" && slot.candidate.cost != null) {
-      return sum + slot.candidate.cost;
-    }
-    return sum;
-  }, 0);
-}
-function getLatestQuota(slots) {
-  for (const slot of slots) {
-    if (slot.status === "ready" && slot.candidate.quota) {
-      return slot.candidate.quota;
-    }
-  }
-  return void 0;
-}
-function hasReadySlot(slots) {
-  return slots.some((s) => s.status === "ready");
-}
-function getSelectedCandidate(slots, selectedIndex) {
-  const slot = slots[selectedIndex];
-  return slot?.status === "ready" ? slot.candidate : void 0;
-}
-function selectNearestReady(slots, startIndex, direction) {
-  for (let i = startIndex + direction; i >= 0 && i < slots.length; i += direction) {
-    if (slots[i]?.status === "ready") {
-      return i;
-    }
-  }
-  return startIndex;
-}
 function collapseToReady(slots) {
   const readySlots = slots.filter((s) => s.status === "ready");
   slots.length = 0;
@@ -868,6 +1293,11 @@ function formatSlot(slot, selected) {
     const meta2 = slot.model ? `${theme.dim}     ${formatModelName(slot.model)}${theme.reset}` : "";
     return meta2 ? [line2, meta2] : [line2];
   }
+  if (slot.status === "error") {
+    const radio2 = "\u25CB";
+    const line2 = `${theme.dim}  ${radio2}  ${slot.content}${theme.reset}`;
+    return [line2];
+  }
   const candidate = slot.candidate;
   const title = candidate.content.split("\n")[0]?.trim() || "";
   const modelInfo = candidate.model ? candidate.cost ? `${formatModelName(candidate.model)} ${formatCost(candidate.cost)}` : formatModelName(candidate.model) : "";
@@ -882,9 +1312,6 @@ function formatSlot(slot, selected) {
   const meta = modelInfo ? `${theme.dim}     ${modelInfo}${theme.reset}` : "";
   return meta ? [line, meta] : [line];
 }
-function formatTotalCostLabel(cost) {
-  return `$${cost.toFixed(6)}`;
-}
 function renderSelector(state, nowMs, renderer) {
   const { slots, selectedIndex, isGenerating, totalSlots } = state;
   const lines = [];
@@ -936,10 +1363,10 @@ function renderError(error, slots, totalSlots, output) {
   }
 }
 function openEditor(content) {
-  return new Promise((resolve, reject) => {
+  return new Promise((resolve3, reject) => {
     const editor = process.env.GIT_EDITOR || process.env.EDITOR || "vi";
-    const tmpDir = mkdtempSync(join3(tmpdir(), "ultrahope-"));
-    const tmpFile = join3(tmpDir, "EDIT_MESSAGE");
+    const tmpDir = mkdtempSync(join4(tmpdir(), "ultrahope-"));
+    const tmpFile = join4(tmpDir, "EDIT_MESSAGE");
     writeFileSync(tmpFile, content);
     const child = spawn(editor, [tmpFile], { stdio: "inherit" });
     child.on("close", (code) => {
@@ -948,9 +1375,9 @@ function openEditor(content) {
         reject(new Error(`Editor exited with code ${code}`));
         return;
       }
-      const result = readFileSync(tmpFile, "utf-8").trim();
+      const result = readFileSync2(tmpFile, "utf-8").trim();
       unlinkSync(tmpFile);
-      resolve(result);
+      resolve3(result);
     });
     child.on("error", (err) => {
       try {
@@ -1010,12 +1437,12 @@ async function selectCandidate(options) {
   );
 }
 async function selectFromSlots(initialSlots, asyncCtx, ttyIo) {
-  return new Promise((resolve) => {
+  return new Promise((resolve3) => {
     let resolved = false;
     const resolveOnce = (result) => {
       if (resolved) return;
       resolved = true;
-      resolve(result);
+      resolve3(result);
     };
     const slots = [...initialSlots];
     const state = {
@@ -1075,10 +1502,10 @@ async function selectFromSlots(initialSlots, asyncCtx, ttyIo) {
     };
     const nextCandidate = async (iterator) => {
       const abortPromise = new Promise(
-        (resolve2) => {
+        (resolve4) => {
           asyncCtx?.abortController.signal.addEventListener(
             "abort",
-            () => resolve2({ done: true, value: void 0 }),
+            () => resolve4({ done: true, value: void 0 }),
             { once: true }
           );
         }
@@ -1103,9 +1530,12 @@ async function selectFromSlots(initialSlots, asyncCtx, ttyIo) {
             const result = await nextCandidate(iterator);
             if (result.done || cleanedUp) break;
             const candidate = result.value;
-            const targetIndex = slots.findIndex(
-              (slot) => slot.status === "pending" ? slot.slotId === candidate.slotId : slot.candidate.slotId === candidate.slotId
-            );
+            const targetIndex = slots.findIndex((slot) => {
+              if (slot.status === "ready") {
+                return slot.candidate.slotId === candidate.slotId;
+              }
+              return slot.status === "pending" && slot.slotId === candidate.slotId;
+            });
             if (targetIndex >= 0 && targetIndex < slots.length) {
               const isNewSlot = slots[targetIndex].status === "pending";
               updateState((draft) => {
@@ -1124,10 +1554,15 @@ async function selectFromSlots(initialSlots, asyncCtx, ttyIo) {
           }
           if (!cleanedUp) {
             cancelGeneration();
+            if (err instanceof InvalidModelError) {
+              cleanup();
+              resolveOnce({ action: "abort", error: err });
+              return;
+            }
             renderer.clearAll();
             renderError(err, slots, state.totalSlots, ttyOutput);
             cleanup(false);
-            resolveOnce({ action: "abort" });
+            resolveOnce({ action: "abort", error: err });
           }
         } finally {
           iterator.return?.();
@@ -1241,173 +1676,163 @@ async function selectFromSlots(initialSlots, asyncCtx, ttyIo) {
   });
 }
 
-// lib/vcs-message-generator.ts
-var DEFAULT_MODELS = [
-  // "mistral/ministral-3b",
-  // "cerebras/qwen-3-235b",
-  // "openai/gpt-5.1",
-  "mistral/ministral-3b",
-  "xai/grok-code-fast-1"
-];
-var isAbortError = (error) => error instanceof Error && error.name === "AbortError";
-var isInvalidCliSessionIdError = (error) => error instanceof Error && error.message.includes("Invalid cliSessionId");
-var delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
-var createAbortPromise = (signal) => signal ? new Promise((resolve) => {
-  if (signal.aborted) {
-    resolve(null);
-    return;
+// lib/stream-capture.ts
+import { mkdirSync as mkdirSync2, writeFileSync as writeFileSync2 } from "fs";
+import { dirname as dirname3, resolve as resolve2 } from "path";
+var noopRecorder = {
+  enabled: false,
+  startGeneration: () => 0,
+  recordEvent: () => {
+  },
+  finishGeneration: () => {
+  },
+  flush: () => null
+};
+function sanitizeEvent(event) {
+  if (event.type === "provider-metadata") {
+    return {
+      type: "provider-metadata",
+      providerMetadata: event.providerMetadata
+    };
   }
-  signal.addEventListener("abort", () => resolve(null), { once: true });
-}) : null;
-async function* generateCommitMessages(options) {
-  const {
-    diff,
-    models,
-    signal,
-    cliSessionId,
-    commandExecutionPromise,
-    useStream = false
-  } = options;
-  const resolvedCliSessionId = cliSessionId;
-  if (!resolvedCliSessionId) {
-    throw new Error("Missing cliSessionId for generate request.");
+  if (event.type === "usage") {
+    return {
+      type: "usage",
+      usage: {
+        inputTokens: event.usage.inputTokens,
+        outputTokens: event.usage.outputTokens,
+        totalTokens: event.usage.totalTokens
+      }
+    };
   }
-  const requiredCliSessionId = resolvedCliSessionId;
-  const token = await getToken();
-  if (!token) {
-    console.error("Error: Not authenticated. Run `ultrahope login` first.");
-    process.exit(1);
+  if (event.type === "commit-message") {
+    return {
+      type: "commit-message",
+      commitMessage: event.commitMessage
+    };
   }
-  const api = createApiClient(token);
-  const generateWithRetry = async function* (payload) {
-    const maxAttempts = 3;
-    for (let attempt = 0; attempt < maxAttempts; attempt++) {
-      try {
-        for await (const event of api.streamCommitMessage(payload, {
-          signal
-        })) {
-          log("generate", event);
-          yield event;
-        }
-        return;
-      } catch (error) {
-        if (signal?.aborted || isAbortError(error)) throw error;
-        if (isInvalidCliSessionIdError(error)) {
-          if (commandExecutionPromise) {
-            try {
-              await commandExecutionPromise;
-              continue;
-            } catch {
-              const abortError = new Error("Aborted");
-              abortError.name = "AbortError";
-              throw abortError;
-            }
-          }
-          if (attempt < maxAttempts - 1) {
-            await delay(80 * (attempt + 1));
-            continue;
-          }
-        }
-        throw error;
-      }
+  return {
+    type: "error",
+    message: event.message
+  };
+}
+function toSerializableCapture(capture) {
+  return {
+    ...capture,
+    runs: capture.runs.map((run) => ({
+      ...run,
+      args: [...run.args],
+      generations: run.generations.map((generation) => ({
+        ...generation,
+        models: [...generation.models],
+        events: generation.events.map((event) => ({
+          atMs: event.atMs,
+          model: event.model,
+          attempt: event.attempt,
+          event: sanitizeEvent(event.event)
+        }))
+      }))
+    }))
+  };
+}
+function createStreamCaptureRecorder(options) {
+  if (!options.path) {
+    return noopRecorder;
+  }
+  const outputPath = resolve2(process.cwd(), options.path);
+  const runStartedAtMs = Date.now();
+  const run = {
+    id: "run-1",
+    command: options.command,
+    args: options.args,
+    apiPath: options.apiPath,
+    startedAt: new Date(runStartedAtMs).toISOString(),
+    generations: []
+  };
+  const capture = {
+    version: 2,
+    source: "ultrahope-commit-message-stream",
+    capturedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    runs: [run]
+  };
+  let generationSequence = 0;
+  let runFinished = false;
+  const activeGenerations = /* @__PURE__ */ new Map();
+  const writeCapture = () => {
+    capture.capturedAt = (/* @__PURE__ */ new Date()).toISOString();
+    mkdirSync2(dirname3(outputPath), { recursive: true });
+    writeFileSync2(
+      outputPath,
+      `${JSON.stringify(toSerializableCapture(capture), null, 2)}
+`,
+      "utf-8"
+    );
+  };
+  const ensureRunFinished = () => {
+    if (runFinished) {
+      return;
     }
-    throw new Error("Failed to generate after retries.");
+    runFinished = true;
+    run.endedAt = (/* @__PURE__ */ new Date()).toISOString();
   };
-  async function* generateForModel(model, slotIndex) {
-    try {
-      if (signal?.aborted) return;
-      let lastCommitMessage = "";
-      let providerMetadata;
-      for await (const event of generateWithRetry({
-        cliSessionId: requiredCliSessionId,
-        input: diff,
-        model
-      })) {
-        if (event.type === "commit-message") {
-          lastCommitMessage = event.commitMessage;
-          if (useStream) {
-            yield {
-              content: lastCommitMessage,
-              slotId: model,
-              model,
-              isPartial: true,
-              slotIndex
-            };
-          }
-        } else if (event.type === "provider-metadata") {
-          providerMetadata = event.providerMetadata;
-        } else if (event.type === "error") {
-          throw new Error(event.message);
-        }
+  return {
+    enabled: true,
+    startGeneration: ({ cliSessionId, models }) => {
+      generationSequence += 1;
+      const startedAtMs = Date.now();
+      const generation = {
+        id: `generation-${generationSequence}`,
+        cliSessionId,
+        models: [...models],
+        startedAt: new Date(startedAtMs).toISOString(),
+        events: []
+      };
+      run.generations.push(generation);
+      activeGenerations.set(generationSequence, { generation, startedAtMs });
+      return generationSequence;
+    },
+    recordEvent: (generationId, record) => {
+      const activeGeneration = activeGenerations.get(generationId);
+      if (!activeGeneration) {
+        return;
       }
-      if (lastCommitMessage) {
-        const { generationId, cost } = extractGatewayMetadata(providerMetadata);
-        yield {
-          content: lastCommitMessage,
-          slotId: model,
-          model,
-          cost,
-          generationId,
-          ...useStream ? { isPartial: false } : {},
-          slotIndex
-        };
+      const eventAtMs = typeof record.event.atMs === "number" && Number.isFinite(record.event.atMs) ? record.event.atMs : Date.now() - activeGeneration.startedAtMs;
+      activeGeneration.generation.events.push({
+        atMs: Math.max(0, Math.round(eventAtMs)),
+        model: record.model,
+        attempt: record.attempt,
+        event: sanitizeEvent(record.event)
+      });
+    },
+    finishGeneration: (generationId) => {
+      const activeGeneration = activeGenerations.get(generationId);
+      if (!activeGeneration) {
+        return;
       }
-    } catch (error) {
-      if (signal?.aborted || isAbortError(error)) return;
-      if (error instanceof InsufficientBalanceError) throw error;
-      if (isInvalidCliSessionIdError(error)) throw error;
-    }
-  }
-  const iterators = models.map((model, index) => ({
-    iterator: generateForModel(model, index)[Symbol.asyncIterator](),
-    index
-  }));
-  const pending = /* @__PURE__ */ new Map();
-  const startNext = (it) => {
-    const promise = it.iterator.next().then((result) => ({
-      result,
-      index: it.index
-    }));
-    pending.set(it.index, {
-      iterator: it.iterator,
-      promise,
-      index: it.index
-    });
-  };
-  for (const it of iterators) {
-    startNext(it);
-  }
-  const abortPromise = createAbortPromise(signal);
-  try {
-    while (pending.size > 0) {
-      if (signal?.aborted) break;
-      const next = Promise.race(
-        Array.from(pending.values()).map((p) => p.promise)
-      );
-      const winner = abortPromise ? await Promise.race([next, abortPromise]) : await next;
-      if (!winner || signal?.aborted) break;
-      const { result, index } = winner;
-      const entry = pending.get(index);
-      if (!entry) continue;
-      if (result.done) {
-        pending.delete(index);
-      } else {
-        yield result.value;
-        startNext({ iterator: entry.iterator, index });
+      activeGeneration.generation.endedAt = (/* @__PURE__ */ new Date()).toISOString();
+      activeGenerations.delete(generationId);
+      writeCapture();
+    },
+    flush: () => {
+      for (const [generationId, activeGeneration] of activeGenerations) {
+        activeGeneration.generation.endedAt = (/* @__PURE__ */ new Date()).toISOString();
+        activeGenerations.delete(generationId);
       }
+      ensureRunFinished();
+      writeCapture();
+      return outputPath;
     }
-  } catch (error) {
-    if (error instanceof InsufficientBalanceError) {
-      console.error(
-        "Error: Token balance exhausted. Upgrade your plan at https://ultrahope.dev/pricing"
-      );
-      process.exit(1);
-    }
-    throw error;
-  }
+  };
 }
 
 // commands/jj.ts
+function exitWithInvalidModelError(error) {
+  console.error(`Error: Model '${error.model}' is not supported.`);
+  if (error.allowedModels.length > 0) {
+    console.error(`Available models: ${error.allowedModels.join(", ")}`);
+  }
+  process.exit(1);
+}
 function showQuotaInfo(quota) {
   const { relative, local } = formatResetTime(quota.resetsAt);
   console.log("");
@@ -1417,24 +1842,48 @@ function showQuotaInfo(quota) {
     )
   );
 }
+function normalizeGuide(value) {
+  if (!value) return void 0;
+  const trimmed = value.trim();
+  if (!trimmed) return void 0;
+  return trimmed.length > 1024 ? trimmed.slice(0, 1024) : trimmed;
+}
 function parseDescribeArgs(args2) {
   let revision = "@";
   let interactive = true;
-  let models = [];
+  let cliModels;
+  let captureStreamPath;
+  let guide;
   for (let i = 0; i < args2.length; i++) {
     const arg = args2[i];
     if (arg === "-r") {
       revision = args2[++i] || "@";
     } else if (arg === "--no-interactive") {
       interactive = false;
-    } else if (arg === "--models" && args2[i + 1]) {
-      models = args2[++i].split(",").map((m) => m.trim());
+    } else if (arg === "--models") {
+      const value = args2[++i];
+      if (!value) {
+        console.error("Error: --models requires a value");
+        process.exit(1);
+      }
+      cliModels = parseModelsArg(value);
+    } else if (arg === "--capture-stream") {
+      const value = args2[++i];
+      if (!value) {
+        console.error("Error: --capture-stream requires a file path");
+        process.exit(1);
+      }
+      captureStreamPath = value;
+    } else if (arg === "--guide") {
+      const value = args2[++i];
+      if (!value) {
+        console.error("Error: --guide requires a text value.");
+        process.exit(1);
+      }
+      guide = normalizeGuide(value);
     }
   }
-  if (models.length === 0) {
-    models = DEFAULT_MODELS;
-  }
-  return { revision, interactive, models };
+  return { revision, interactive, cliModels, captureStreamPath, guide };
 }
 function getJjDiff(revision) {
   try {
@@ -1466,7 +1915,7 @@ function assertDiffAvailable(revision, diff) {
     process.exit(1);
   }
 }
-async function initCommandExecutionContext(args2, options, diff) {
+async function initCommandExecutionContext(args2, models, diff, guide) {
   const token = await getToken();
   if (!token) {
     console.error("Error: Not authenticated. Run `ultrahope login` first.");
@@ -1481,13 +1930,14 @@ async function initCommandExecutionContext(args2, options, diff) {
     requestPayload: {
       input: diff,
       target: "vcs-commit-message",
-      models: options.models
+      models,
+      ...guide ? { guide } : {}
     }
   });
   commandExecutionPromise.catch(async (error) => {
     abortController.abort(abortReasonForError(error));
     await handleCommandExecutionError(error, {
-      progress: { ready: 0, total: options.models.length }
+      progress: { ready: 0, total: models.length }
     });
   });
   return {
@@ -1512,41 +1962,53 @@ async function recordSelection(apiClient, generationId) {
     console.error(`Warning: Failed to record selection. ${message}`);
   }
 }
-function createCandidateFactory(diff, options, context) {
+function createCandidateFactory(diff, models, context, captureRecorder, guide) {
   return (signal) => generateCommitMessages({
     diff,
-    models: options.models,
+    models,
+    guide,
     signal: mergeAbortSignals(signal, context.commandExecutionSignal),
     cliSessionId: context.cliSessionId,
     commandExecutionPromise: context.commandExecutionPromise,
-    useStream: true
+    useStream: true,
+    streamCaptureRecorder: captureRecorder
   });
 }
-async function runNonInteractiveDescribe(options, diff, context) {
+async function runNonInteractiveDescribe(revision, models, diff, context, captureRecorder, guide) {
   const gen = generateCommitMessages({
     diff,
-    models: options.models.slice(0, 1),
+    models: models.slice(0, 1),
+    guide,
     signal: context.commandExecutionSignal,
     cliSessionId: context.cliSessionId,
     commandExecutionPromise: context.commandExecutionPromise,
-    useStream: true
+    useStream: true,
+    streamCaptureRecorder: captureRecorder
+  });
+  const first = await gen.next().catch((error) => {
+    if (error instanceof InvalidModelError) {
+      exitWithInvalidModelError(error);
+    }
+    throw error;
   });
-  const first = await gen.next();
   await recordSelection(context.apiClient, first.value?.generationId);
   const message = first.value?.content ?? "";
-  describeRevision(options.revision, message);
+  describeRevision(revision, message);
 }
-async function runInteractiveDescribe(options, createCandidates, context) {
+async function runInteractiveDescribe(options, models, createCandidates, context) {
   const stats = getJjDiffStats(options.revision);
   console.log(ui.success(`Found ${formatDiffStats(stats)}`));
   while (true) {
     const result = await selectCandidate({
       createCandidates,
-      maxSlots: options.models.length,
+      maxSlots: models.length,
       abortSignal: context.commandExecutionSignal,
-      models: options.models
+      models
     });
     if (result.action === "abort") {
+      if (result.error instanceof InvalidModelError) {
+        exitWithInvalidModelError(result.error);
+      }
       if (isCommandExecutionAbort(context.commandExecutionSignal)) {
         return;
       }
@@ -1577,29 +2039,100 @@ async function runInteractiveDescribe(options, createCandidates, context) {
 }
 async function describe(args2) {
   const options = parseDescribeArgs(args2);
+  const models = resolveModels(options.cliModels);
   const diff = getJjDiff(options.revision);
   assertDiffAvailable(options.revision, diff);
-  const context = await initCommandExecutionContext(args2, options, diff);
-  const createCandidates = createCandidateFactory(diff, options, context);
-  if (!options.interactive) {
-    await runNonInteractiveDescribe(options, diff, context);
-    return;
+  const captureRecorder = createStreamCaptureRecorder({
+    path: options.captureStreamPath,
+    command: "ultrahope jj describe",
+    args: ["describe", ...args2],
+    apiPath: "/v1/commit-message/stream"
+  });
+  try {
+    const context = await initCommandExecutionContext(
+      args2,
+      models,
+      diff,
+      options.guide
+    );
+    const createCandidates = createCandidateFactory(
+      diff,
+      models,
+      context,
+      captureRecorder,
+      options.guide
+    );
+    if (!options.interactive) {
+      await runNonInteractiveDescribe(
+        options.revision,
+        models,
+        diff,
+        context,
+        captureRecorder,
+        options.guide
+      );
+      return;
+    }
+    await runInteractiveDescribe(options, models, createCandidates, context);
+  } finally {
+    const capturePath = captureRecorder.flush();
+    if (capturePath) {
+      console.log(ui.hint(`Captured stream replay to ${capturePath}`));
+    }
   }
-  await runInteractiveDescribe(options, createCandidates, context);
+}
+function setup() {
+  try {
+    const existing = execFileSync(
+      "jj",
+      ["config", "get", "aliases.ultrahope"],
+      { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }
+    ).trim();
+    if (existing) {
+      console.log(ui.success("jj alias 'ultrahope' is already configured."));
+      console.log(ui.hint("  Run `jj ultrahope describe` to use it."));
+      return;
+    }
+  } catch {
+  }
+  execFileSync(
+    "jj",
+    [
+      "config",
+      "set",
+      "--user",
+      "aliases.ultrahope",
+      '["util", "exec", "--", "ultrahope", "jj"]'
+    ],
+    { stdio: "inherit" }
+  );
+  console.log(ui.success("Added jj alias 'ultrahope'."));
+  console.log(
+    ui.hint(
+      "  You can now run `jj ultrahope describe` instead of `ultrahope jj describe`."
+    )
+  );
 }
 function printHelp() {
   console.log(`Usage: ultrahope jj <command>
 
 Commands:
    describe    Generate commit description from changes
+   setup       Register 'ultrahope' as a jj alias
 
 Describe options:
    -r <revset>       Revision to describe (default: @)
    --no-interactive  Single candidate, no selection
+   --guide <text>     Additional context to guide message generation
+   --models <list>   Comma-separated model list (overrides config)
+   --capture-stream <path>  Save candidate stream as replay JSON
 
 Examples:
    ultrahope jj describe              # interactive mode
-   ultrahope jj describe -r @-        # for parent revision`);
+   ultrahope jj describe -r @-        # for parent revision
+   ultrahope jj describe --guide "GHSA-gq3j-xvxp-8hrf: override reason"
+   ultrahope jj describe --capture-stream packages/web/lib/demo/commit-message-stream.capture.json
+   ultrahope jj setup                 # enable \`jj ultrahope\` alias`);
 }
 async function jj(args2) {
   const [command2, ...rest] = args2;
@@ -1607,6 +2140,9 @@ async function jj(args2) {
     case "describe":
       await describe(rest);
       break;
+    case "setup":
+      setup();
+      break;
     case "--help":
     case "-h":
     case void 0:
@@ -1636,6 +2172,7 @@ async function login(_args) {
     deviceCode.expires_in
   );
   await saveToken(token);
+  await ensureGlobalConfigFile();
   console.log("Successfully authenticated!");
 }
 async function pollForToken(api, deviceCode, interval, expiresIn) {
@@ -1653,7 +2190,7 @@ async function pollForToken(api, deviceCode, interval, expiresIn) {
   throw new Error("Authentication timed out");
 }
 function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
+  return new Promise((resolve3) => setTimeout(resolve3, ms));
 }
 
 // lib/stdin.ts
@@ -1676,6 +2213,13 @@ var TARGET_TO_API_PATH = {
   "pr-title-body": "/v1/pr-title-body",
   "pr-intent": "/v1/pr-intent"
 };
+function exitWithInvalidModelError2(error) {
+  console.error(`Error: Model '${error.model}' is not supported.`);
+  if (error.allowedModels.length > 0) {
+    console.error(`Available models: ${error.allowedModels.join(", ")}`);
+  }
+  process.exit(1);
+}
 async function translate(args2) {
   const options = parseArgs(args2);
   const input = await stdin();
@@ -1685,6 +2229,12 @@ async function translate(args2) {
     );
     process.exit(1);
   }
+  if (options.captureStreamPath && options.target !== "vcs-commit-message") {
+    console.error(
+      "Error: --capture-stream is only supported with --target vcs-commit-message."
+    );
+    process.exit(1);
+  }
   if (options.target === "vcs-commit-message") {
     await handleVcsCommitMessage(input, options, args2);
     return;
@@ -1692,90 +2242,113 @@ async function translate(args2) {
   await handleGenericTarget(input, options, args2);
 }
 async function handleVcsCommitMessage(input, options, args2) {
-  const models = options.model ? [options.model] : DEFAULT_MODELS;
-  const token = await getToken();
-  if (!token) {
-    console.error("Error: Not authenticated. Run `ultrahope login` first.");
-    process.exit(1);
-  }
-  const api = createApiClient(token);
-  const {
-    commandExecutionPromise: promise,
-    abortController,
-    cliSessionId: id
-  } = startCommandExecution({
-    api,
-    command: "translate",
+  const captureRecorder = createStreamCaptureRecorder({
+    path: options.captureStreamPath,
+    command: "ultrahope translate",
     args: args2,
-    apiPath: TARGET_TO_API_PATH[options.target],
-    requestPayload: models.length === 1 ? { input, target: "vcs-commit-message", model: models[0] } : { input, target: "vcs-commit-message", models }
+    apiPath: "/v1/commit-message/stream"
   });
-  const cliSessionId = id;
-  const commandExecutionSignal = abortController.signal;
-  const commandExecutionPromise = promise;
-  const apiClient = api;
-  commandExecutionPromise.catch(async (error) => {
-    abortController.abort(abortReasonForError(error));
-    await handleCommandExecutionError(error, {
-      progress: { ready: 0, total: models.length }
+  const models = resolveModels(options.cliModels);
+  try {
+    const token = await getToken();
+    if (!token) {
+      console.error("Error: Not authenticated. Run `ultrahope login` first.");
+      process.exit(1);
+    }
+    const api = createApiClient(token);
+    const {
+      commandExecutionPromise: promise,
+      abortController,
+      cliSessionId: id
+    } = startCommandExecution({
+      api,
+      command: "translate",
+      args: args2,
+      apiPath: TARGET_TO_API_PATH[options.target],
+      requestPayload: models.length === 1 ? { input, target: "vcs-commit-message", model: models[0] } : { input, target: "vcs-commit-message", models }
     });
-  });
-  const recordSelection2 = async (generationId) => {
-    if (!generationId || !apiClient) return;
-    try {
-      await apiClient.recordGenerationScore({
-        generationId,
-        value: 1
+    const cliSessionId = id;
+    const commandExecutionSignal = abortController.signal;
+    const commandExecutionPromise = promise;
+    const apiClient = api;
+    commandExecutionPromise.catch(async (error) => {
+      abortController.abort(abortReasonForError(error));
+      await handleCommandExecutionError(error, {
+        progress: { ready: 0, total: models.length }
       });
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      if (message.includes("Generation not found")) {
-        return;
+    });
+    const recordSelection2 = async (generationId) => {
+      if (!generationId || !apiClient) return;
+      try {
+        await apiClient.recordGenerationScore({
+          generationId,
+          value: 1
+        });
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        if (message.includes("Generation not found")) {
+          return;
+        }
+        console.error(`Warning: Failed to record selection. ${message}`);
       }
-      console.error(`Warning: Failed to record selection. ${message}`);
-    }
-  };
-  const createCandidates = (signal) => generateCommitMessages({
-    diff: input,
-    models,
-    signal: mergeAbortSignals(signal, commandExecutionSignal),
-    cliSessionId,
-    commandExecutionPromise
-  });
-  if (!options.interactive) {
-    const gen = generateCommitMessages({
+    };
+    const createCandidates = (signal) => generateCommitMessages({
       diff: input,
-      models: models.slice(0, 1),
-      signal: commandExecutionSignal,
+      models,
+      signal: mergeAbortSignals(signal, commandExecutionSignal),
       cliSessionId,
-      commandExecutionPromise
-    });
-    const first = await gen.next();
-    await recordSelection2(first.value?.generationId);
-    console.log(first.value?.content ?? "");
-    return;
-  }
-  while (true) {
-    const result = await selectCandidate({
-      createCandidates,
-      maxSlots: models.length,
-      abortSignal: commandExecutionSignal,
-      models
+      commandExecutionPromise,
+      streamCaptureRecorder: captureRecorder
     });
-    if (result.action === "abort") {
-      if (isCommandExecutionAbort(commandExecutionSignal)) {
+    if (!options.interactive) {
+      const gen = generateCommitMessages({
+        diff: input,
+        models: models.slice(0, 1),
+        signal: commandExecutionSignal,
+        cliSessionId,
+        commandExecutionPromise,
+        streamCaptureRecorder: captureRecorder
+      });
+      const first = await gen.next().catch((error) => {
+        if (error instanceof InvalidModelError) {
+          exitWithInvalidModelError2(error);
+        }
+        throw error;
+      });
+      await recordSelection2(first.value?.generationId);
+      console.log(first.value?.content ?? "");
+      return;
+    }
+    while (true) {
+      const result = await selectCandidate({
+        createCandidates,
+        maxSlots: models.length,
+        abortSignal: commandExecutionSignal,
+        models
+      });
+      if (result.action === "abort") {
+        if (result.error instanceof InvalidModelError) {
+          exitWithInvalidModelError2(result.error);
+        }
+        if (isCommandExecutionAbort(commandExecutionSignal)) {
+          return;
+        }
+        console.error("Aborted.");
+        process.exit(1);
+      }
+      if (result.action === "reroll") {
+        continue;
+      }
+      if (result.action === "confirm" && result.selected) {
+        await recordSelection2(result.selectedCandidate?.generationId);
+        console.log(result.selected);
         return;
       }
-      console.error("Aborted.");
-      process.exit(1);
     }
-    if (result.action === "reroll") {
-      continue;
-    }
-    if (result.action === "confirm" && result.selected) {
-      await recordSelection2(result.selectedCandidate?.generationId);
-      console.log(result.selected);
-      return;
+  } finally {
+    const capturePath = captureRecorder.flush();
+    if (capturePath) {
+      console.log(`Captured stream replay to ${capturePath}`);
     }
   }
 }
@@ -1786,7 +2359,7 @@ async function handleGenericTarget(input, options, args2) {
     process.exit(1);
   }
   const api = createApiClient(token);
-  const models = options.model ? [options.model] : DEFAULT_MODELS;
+  const models = resolveModels(options.cliModels);
   const defaultModel = models[0];
   const requestPayload = models.length === 1 ? { input, target: options.target, model: models[0] } : { input, target: options.target, models };
   const {
@@ -1808,7 +2381,7 @@ async function handleGenericTarget(input, options, args2) {
   );
   const isAbortError2 = (error) => error instanceof Error && error.name === "AbortError";
   const isInvalidCliSessionIdError2 = (error) => error instanceof Error && error.message.includes("Invalid cliSessionId");
-  const delay2 = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+  const delay2 = (ms) => new Promise((resolve3) => setTimeout(resolve3, ms));
   const generateFn = (req) => {
     if (options.target === "pr-title-body") {
       return api.generatePrTitleBody(req, { signal: abortController.signal });
@@ -1858,10 +2431,11 @@ async function handleGenericTarget(input, options, args2) {
         if (isAbortError2(error) || abortController.signal.aborted) {
           return candidates2;
         }
+        if (error instanceof InvalidModelError) {
+          exitWithInvalidModelError2(error);
+        }
         if (error instanceof InsufficientBalanceError) {
-          console.error(
-            "Error: Token balance exhausted. Upgrade your plan at https://ultrahope.dev/pricing"
-          );
+          console.error(error.formatMessage());
           process.exit(1);
         }
         throw error;
@@ -1878,10 +2452,11 @@ async function handleGenericTarget(input, options, args2) {
       if (isAbortError2(error) || abortController.signal.aborted) {
         return null;
       }
+      if (error instanceof InvalidModelError) {
+        exitWithInvalidModelError2(error);
+      }
       if (error instanceof InsufficientBalanceError) {
-        console.error(
-          "Error: Token balance exhausted. Upgrade your plan at https://ultrahope.dev/pricing"
-        );
+        console.error(error.formatMessage());
         process.exit(1);
       }
       throw error;
@@ -1918,6 +2493,9 @@ async function handleGenericTarget(input, options, args2) {
       models: candidates.map((c) => c.model).filter(Boolean)
     });
     if (result.action === "abort") {
+      if (result.error instanceof InvalidModelError) {
+        exitWithInvalidModelError2(result.error);
+      }
       console.error("Aborted.");
       process.exit(1);
     }
@@ -1947,7 +2525,8 @@ async function handleGenericTarget(input, options, args2) {
 function parseArgs(args2) {
   let target;
   let interactive = true;
-  let model;
+  let cliModels;
+  let captureStreamPath;
   for (let i = 0; i < args2.length; i++) {
     const arg = args2[i];
     if (arg === "--target" || arg === "-t") {
@@ -1960,13 +2539,23 @@ function parseArgs(args2) {
       target = value;
     } else if (arg === "--no-interactive") {
       interactive = false;
+    } else if (arg === "--models") {
+      const value = args2[++i];
+      if (!value) {
+        console.error("Error: --models requires a value");
+        process.exit(1);
+      }
+      cliModels = parseModelsArg(value);
     } else if (arg === "--model") {
+      console.error("Error: --model is no longer supported. Use --models.");
+      process.exit(1);
+    } else if (arg === "--capture-stream") {
       const value = args2[++i];
       if (!value) {
-        console.error("Error: --model requires a value");
+        console.error("Error: --capture-stream requires a file path");
         process.exit(1);
       }
-      model = value;
+      captureStreamPath = value;
     }
   }
   if (!target) {
@@ -1976,12 +2565,60 @@ function parseArgs(args2) {
     );
     process.exit(1);
   }
-  return { target, interactive, model };
+  return { target, interactive, cliModels, captureStreamPath };
 }
 
+// package.json
+var package_default = {
+  name: "ultrahope",
+  version: "0.1.4",
+  description: "LLM-powered development workflow assistant",
+  type: "module",
+  license: "MIT",
+  repository: {
+    type: "git",
+    url: "git+https://github.com/toyamarinyon/ultrahope.git"
+  },
+  keywords: [
+    "cli",
+    "llm",
+    "ai",
+    "git",
+    "commit-message",
+    "pull-request"
+  ],
+  bin: {
+    ultrahope: "dist/index.js",
+    "git-ultrahope": "dist/git-ultrahope.js",
+    "git-hope": "dist/git-ultrahope.js",
+    "git-uh": "dist/git-ultrahope.js"
+  },
+  files: [
+    "dist"
+  ],
+  scripts: {
+    build: "tsup",
+    prebuild: "bun run generate:client",
+    "generate:client": "tsx scripts/generate-client.ts",
+    typecheck: "tsc --noEmit",
+    prepublishOnly: "bun run build"
+  },
+  dependencies: {
+    open: "^11.0.0",
+    "openapi-fetch": "^0.15.0",
+    "smol-toml": "^1.4.1"
+  },
+  devDependencies: {
+    "@ultrahope/web": "workspace:*",
+    "@types/node": "^22.15.29",
+    "openapi-typescript": "^7.10.1",
+    tsup: "8.5.0",
+    typescript: "^5.8.3"
+  }
+};
+
 // index.ts
-var require2 = createRequire(import.meta.url);
-var { version } = require2("../package.json");
+var { version } = package_default;
 var [command, ...args] = process.argv.slice(2);
 async function main() {
   switch (command) {