ultrahope 0.1.2 → 0.1.4

package/dist/git-ultrahope.js

@@ -1,10 +1,7 @@
 #!/usr/bin/env node
 
 // commands/commit.ts
-import { execSync as execSync2, spawn as spawn2 } from "child_process";
-import { mkdtempSync as mkdtempSync2, readFileSync as readFileSync2, unlinkSync as unlinkSync2, writeFileSync as writeFileSync2 } from "fs";
-import { tmpdir as tmpdir2 } from "os";
-import { join as join4 } from "path";
+import { execSync as execSync2 } 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 });
@@ -558,7 +615,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({
@@ -581,17 +638,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;
       }
     };
@@ -608,7 +665,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({
@@ -628,7 +685,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);
@@ -692,11 +749,358 @@ 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;
+}
+
 // lib/diff-stats.ts
 import { execSync } from "child_process";
 function getGitStagedStats() {
@@ -736,83 +1140,28 @@ 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;
-}
-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);
-      readline2.cursorTo(output, 0);
-      readline2.clearScreenDown(output);
-    }
-    output.write(content);
-    pendingHeight = content.split("\n").length - 1;
-  };
-  const flush = () => {
-    committedHeight += pendingHeight;
-    pendingHeight = 0;
-  };
-  const clearAll = () => {
-    if (!isTTY(output)) {
-      return;
-    }
-    const totalHeight = pendingHeight + committedHeight;
-    if (totalHeight > 0) {
-      readline2.moveCursor(output, 0, -totalHeight);
-      readline2.cursorTo(output, 0);
-      readline2.clearScreenDown(output);
-    }
-    pendingHeight = 0;
-    committedHeight = 0;
-  };
-  const reset = () => {
-    pendingHeight = 0;
-    committedHeight = 0;
-  };
-  return { render, flush, clearAll, reset };
-}
-
-// lib/selector.ts
-var TTY_PATH = "/dev/tty";
-function formatModelName(model) {
-  const parts = model.split("/");
-  return parts.length > 1 ? parts[1] : model;
+// ../shared/terminal-selector-helpers.ts
+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 formatTotalCostLabel(cost) {
+  return `$${cost.toFixed(6)}`;
+}
 function getReadyCount(slots) {
-  return slots.filter((s) => s.status === "ready").length;
+  return slots.filter((slot) => slot.status === "ready").length;
 }
 function getTotalCost(slots) {
   return slots.reduce((sum, slot) => {
@@ -831,20 +1180,80 @@ function getLatestQuota(slots) {
   return void 0;
 }
 function hasReadySlot(slots) {
-  return slots.some((s) => s.status === "ready");
+  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;
 }
-function selectNearestReady(slots, startIndex, direction) {
-  for (let i = startIndex + direction; i >= 0 && i < slots.length; i += direction) {
-    if (slots[i]?.status === "ready") {
-      return i;
+
+// 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;
     }
-  }
-  return startIndex;
+    if (pendingHeight > 0) {
+      readline2.moveCursor(output, 0, -pendingHeight);
+      readline2.cursorTo(output, 0);
+      readline2.clearScreenDown(output);
+    }
+    output.write(content);
+    pendingHeight = content.split("\n").length - 1;
+  };
+  const flush = () => {
+    committedHeight += pendingHeight;
+    pendingHeight = 0;
+  };
+  const clearAll = () => {
+    if (!isTTY(output)) {
+      return;
+    }
+    const totalHeight = pendingHeight + committedHeight;
+    if (totalHeight > 0) {
+      readline2.moveCursor(output, 0, -totalHeight);
+      readline2.cursorTo(output, 0);
+      readline2.clearScreenDown(output);
+    }
+    pendingHeight = 0;
+    committedHeight = 0;
+  };
+  const reset = () => {
+    pendingHeight = 0;
+    committedHeight = 0;
+  };
+  return { render, flush, clearAll, reset };
 }
+
+// lib/selector.ts
+var TTY_PATH = "/dev/tty";
 function collapseToReady(slots) {
   const readySlots = slots.filter((s) => s.status === "ready");
   slots.length = 0;
@@ -859,6 +1268,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) : "";
@@ -873,9 +1287,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 = [];
@@ -927,10 +1338,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) => {
@@ -939,9 +1350,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 {
@@ -1001,12 +1412,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 = {
@@ -1066,10 +1477,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 }
           );
         }
@@ -1094,9 +1505,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) => {
@@ -1115,10 +1529,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?.();
@@ -1232,173 +1651,169 @@ 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/commit.ts
+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 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("");
@@ -1409,21 +1824,42 @@ function showQuotaInfo(quota) {
   );
 }
 function parseArgs(args2) {
-  let models = [];
+  let cliModels;
+  let captureStreamPath;
+  let guide;
   for (let i = 0; i < args2.length; i++) {
     const arg = args2[i];
-    if (arg === "--models" && args2[i + 1]) {
-      models = args2[i + 1].split(",").map((m) => m.trim());
+    if (arg === "--models") {
+      const value = args2[i + 1];
+      if (!value) {
+        console.error("Error: --models requires a value");
+        process.exit(1);
+      }
+      cliModels = parseModelsArg(value);
+      i++;
+    } else if (arg === "--capture-stream") {
+      const value = args2[i + 1];
+      if (!value) {
+        console.error("Error: --capture-stream requires a file path");
+        process.exit(1);
+      }
+      captureStreamPath = value;
+      i++;
+    } else if (arg === "--guide") {
+      const value = args2[i + 1];
+      if (!value) {
+        console.error("Error: --guide requires a text value.");
+        process.exit(1);
+      }
+      guide = normalizeGuide(value);
       i++;
     }
   }
-  if (models.length === 0) {
-    models = DEFAULT_MODELS;
-  }
   return {
-    message: args2.includes("-m") || args2.includes("--message"),
     interactive: !args2.includes("--no-interactive"),
-    models
+    cliModels,
+    captureStreamPath,
+    guide
   };
 }
 function getStagedDiff() {
@@ -1436,31 +1872,6 @@ function getStagedDiff() {
     process.exit(1);
   }
 }
-function openEditor2(initialMessage) {
-  return new Promise((resolve, reject) => {
-    const editor = process.env.GIT_EDITOR || process.env.EDITOR || "vi";
-    const tmpDir = mkdtempSync2(join4(tmpdir2(), "ultrahope-"));
-    const tmpFile = join4(tmpDir, "COMMIT_EDITMSG");
-    writeFileSync2(tmpFile, initialMessage);
-    const child = spawn2(editor, [tmpFile], {
-      stdio: "inherit"
-    });
-    child.on("close", (code) => {
-      if (code !== 0) {
-        unlinkSync2(tmpFile);
-        reject(new Error(`Editor exited with code ${code}`));
-        return;
-      }
-      const message = readFileSync2(tmpFile, "utf-8").trim();
-      unlinkSync2(tmpFile);
-      resolve(message);
-    });
-    child.on("error", (err) => {
-      unlinkSync2(tmpFile);
-      reject(err);
-    });
-  });
-}
 function commitWithMessage(message) {
   try {
     execSync2(`git commit -m ${JSON.stringify(message)}`, { stdio: "inherit" });
@@ -1470,6 +1881,13 @@ function commitWithMessage(message) {
 }
 async function commit(args2) {
   const options = parseArgs(args2);
+  const captureRecorder = createStreamCaptureRecorder({
+    path: options.captureStreamPath,
+    command: "git ultrahope commit",
+    args: ["commit", ...args2],
+    apiPath: "/v1/commit-message/stream"
+  });
+  const models = resolveModels(options.cliModels);
   const diff = getStagedDiff();
   if (!diff.trim()) {
     console.error(
@@ -1477,123 +1895,123 @@ async function commit(args2) {
     );
     process.exit(1);
   }
-  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: "commit",
-    args: args2,
-    apiPath: "/v1/commit-message",
-    requestPayload: {
-      input: diff,
-      target: "vcs-commit-message",
-      models: options.models
+  try {
+    const token = await getToken();
+    if (!token) {
+      console.error("Error: Not authenticated. Run `ultrahope login` first.");
+      process.exit(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: options.models.length }
+    const api = createApiClient(token);
+    const {
+      commandExecutionPromise: promise,
+      abortController,
+      cliSessionId: id
+    } = startCommandExecution({
+      api,
+      command: "commit",
+      args: args2,
+      apiPath: "/v1/commit-message",
+      requestPayload: {
+        input: diff,
+        target: "vcs-commit-message",
+        model: models[0],
+        ...options.guide ? { guide: options.guide } : {}
+      }
     });
-  });
-  const recordSelection = 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 recordSelection = 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,
-    models: options.models,
-    signal: mergeAbortSignals(signal, commandExecutionSignal),
-    cliSessionId,
-    commandExecutionPromise
-  });
-  if (!options.interactive) {
-    const gen = generateCommitMessages({
+    };
+    const createCandidates = (signal) => generateCommitMessages({
       diff,
-      models: options.models.slice(0, 1),
-      signal: commandExecutionSignal,
+      models,
+      guide: options.guide,
+      signal: mergeAbortSignals(signal, commandExecutionSignal),
       cliSessionId,
-      commandExecutionPromise
+      commandExecutionPromise,
+      streamCaptureRecorder: captureRecorder
     });
-    const first = await gen.next();
-    await recordSelection(first.value?.generationId);
-    const message = first.value?.content ?? "";
-    if (options.message) {
+    if (!options.interactive) {
+      const gen = generateCommitMessages({
+        diff,
+        models: models.slice(0, 1),
+        guide: options.guide,
+        signal: commandExecutionSignal,
+        cliSessionId,
+        commandExecutionPromise,
+        streamCaptureRecorder: captureRecorder
+      });
+      const first = await gen.next().catch((error) => {
+        if (error instanceof InvalidModelError) {
+          exitWithInvalidModelError(error);
+        }
+        throw error;
+      });
+      await recordSelection(first.value?.generationId);
+      const message = first.value?.content ?? "";
       commitWithMessage(message);
       return;
     }
-    const editedMessage = await openEditor2(message);
-    if (!editedMessage) {
-      console.error("Aborting commit due to empty message.");
-      process.exit(1);
-    }
-    commitWithMessage(editedMessage);
-    return;
-  }
-  const stats = getGitStagedStats();
-  console.log(ui.success(`Found ${formatDiffStats(stats)}`));
-  while (true) {
-    const result = await selectCandidate({
-      createCandidates,
-      maxSlots: options.models.length,
-      abortSignal: commandExecutionSignal,
-      models: options.models
-    });
-    if (result.action === "abort") {
-      if (isCommandExecutionAbort(commandExecutionSignal)) {
-        return;
+    const stats = getGitStagedStats();
+    console.log(ui.success(`Found ${formatDiffStats(stats)}`));
+    while (true) {
+      const result = await selectCandidate({
+        createCandidates,
+        maxSlots: models.length,
+        abortSignal: commandExecutionSignal,
+        models
+      });
+      if (result.action === "abort") {
+        if (result.error instanceof InvalidModelError) {
+          exitWithInvalidModelError(result.error);
+        }
+        if (isCommandExecutionAbort(commandExecutionSignal)) {
+          return;
+        }
+        console.error("Aborting commit.");
+        process.exit(1);
       }
-      console.error("Aborting commit.");
-      process.exit(1);
-    }
-    if (result.action === "reroll") {
-      continue;
-    }
-    if (result.action === "confirm" && result.selected) {
-      await recordSelection(result.selectedCandidate?.generationId);
-      const costLabel = result.totalCost != null ? ` (total: ${formatTotalCost(result.totalCost)})` : "";
-      console.log(ui.success(`Message selected${costLabel}`));
-      if (options.message) {
+      if (result.action === "reroll") {
+        continue;
+      }
+      if (result.action === "confirm" && result.selected) {
+        await recordSelection(result.selectedCandidate?.generationId);
+        const costLabel = result.totalCost != null ? ` (total: ${formatTotalCost(result.totalCost)})` : "";
+        console.log(ui.success(`Message selected${costLabel}`));
         console.log(`${ui.success("Running git commit")}
 `);
         commitWithMessage(result.selected);
-      } else {
-        const editedMessage = await openEditor2(result.selected);
-        if (!editedMessage) {
-          console.error("Aborting commit due to empty message.");
-          process.exit(1);
+        if (result.quota) {
+          showQuotaInfo(result.quota);
         }
-        console.log(`${ui.success("Running git commit")}
-`);
-        commitWithMessage(editedMessage);
-      }
-      if (result.quota) {
-        showQuotaInfo(result.quota);
+        return;
       }
-      return;
+    }
+  } finally {
+    const capturePath = captureRecorder.flush();
+    if (capturePath) {
+      console.log(ui.hint(`Captured stream replay to ${capturePath}`));
     }
   }
 }
@@ -1623,13 +2041,16 @@ Commands:
    commit      Generate commit message from staged changes
 
 Commit options:
-   -m, --message     Commit directly with generated message
-   --no-interactive  Single candidate, open in editor
+   --no-interactive  Single candidate, commit directly
+   --guide <text>     Additional context to guide message generation
+   --models <list>   Comma-separated model list (overrides config)
+   --capture-stream <path>  Save commit-message stream as replay JSON
 
 Examples:
    git ultrahope commit               # interactive selector (default)
-   git ultrahope commit -m            # select and commit directly
-   git ultrahope commit --no-interactive  # single candidate, open editor`);
+   git ultrahope commit --guide "GHSA-gq3j-xvxp-8hrf: override reason"
+   git ultrahope commit --capture-stream /tmp/git-commit-stream.capture.json
+   git ultrahope commit --no-interactive  # single candidate, commit directly`);
 }
 main().catch((err) => {
   console.error(err);