@garuda-agent/garuda 0.0.1 → 0.15.0

package/dist/cli/index.js

@@ -0,0 +1,1203 @@
+#!/usr/bin/env node
+import {
+  BUILD_PROMPT,
+  CommandArgs,
+  FOCUS_REPORTING_OFF,
+  FocusTracker,
+  commandNames,
+  complete,
+  describeError,
+  formatTokens,
+  planHandoff,
+  reportsFocus,
+  rootFiles,
+  rootLister,
+  runCommand,
+  runTurnInTerminal,
+  stopMessage
+} from "../chunk-PQNT34LY.js";
+import {
+  PlainRenderer
+} from "../chunk-FARS4R67.js";
+import {
+  AutoApprover
+} from "../chunk-NXJ4XLB5.js";
+import {
+  Notifier,
+  pickChannel
+} from "../chunk-N4I6YS3E.js";
+import {
+  SwitchApprover,
+  TerminalApprover
+} from "../chunk-4JSUUDFQ.js";
+import {
+  hasProviderKey,
+  keepProviderKey,
+  loadModelsConfig,
+  resolveModel
+} from "../chunk-YFQJXRIJ.js";
+import {
+  DEFAULT_MAX_TOKENS,
+  FileSessionStore,
+  Runtime,
+  ToolRegistry,
+  auditDirFor,
+  closeOpenToolCalls,
+  createSession,
+  defaultTools,
+  parseRecords,
+  popPoint,
+  pushPoint,
+  rebuildState,
+  redoPoint,
+  runAgent,
+  signature
+} from "../chunk-K7KK7U44.js";
+import "../chunk-A2QAIRQL.js";
+import "../chunk-HRGX53VC.js";
+import "../chunk-G2AX7MGS.js";
+import {
+  loadSearchConfig
+} from "../chunk-B25VL4RU.js";
+import {
+  BUILTIN_COMMANDS
+} from "../chunk-23FXBNBB.js";
+import "../chunk-EU7PA45O.js";
+import {
+  VERSION
+} from "../chunk-EPKWDCV4.js";
+import "../chunk-5DEWP3YX.js";
+import "../chunk-ZAE25JM2.js";
+import "../chunk-ATW7BNIG.js";
+import "../chunk-PZS3V6P3.js";
+import "../chunk-OUCV3FCT.js";
+import {
+  JOB_DENIAL
+} from "../chunk-SI2QJYCR.js";
+import "../chunk-WMOLXTBU.js";
+import "../chunk-HUIK3WXO.js";
+import "../chunk-KKB5W47S.js";
+import "../chunk-3NJNVZTK.js";
+
+// src/cli/index.ts
+import { existsSync, readFileSync, realpathSync } from "fs";
+import { homedir as homedir2 } from "os";
+import { join } from "path";
+import { Writable } from "stream";
+import { Command, Option } from "commander";
+
+// src/loop/replay.ts
+import { isDeepStrictEqual } from "util";
+
+// src/model/fake.ts
+var ScriptExhaustedError = class extends Error {
+  constructor(calls) {
+    super(`Fake model script has no step for call ${calls}.`);
+    this.name = "ScriptExhaustedError";
+  }
+};
+var FakeModelClient = class {
+  requests = [];
+  /** Server tools the fake accepts, like a Claude model (0.6). Default: none. */
+  serverTools;
+  steps;
+  constructor(steps, options = {}) {
+    this.steps = [...steps];
+    if (options.serverTools !== void 0) this.serverTools = options.serverTools;
+  }
+  get remaining() {
+    return this.steps.length;
+  }
+  async *stream(request, options) {
+    options?.signal?.throwIfAborted();
+    this.requests.push(structuredClone(request));
+    const step = this.steps.shift();
+    if (step === void 0) throw new ScriptExhaustedError(this.requests.length);
+    const response = typeof step === "function" ? step(request) : step;
+    for (const block of response.content) {
+      if (block.type === "text") yield { type: "text_delta", text: block.text };
+      if (block.type === "thinking" && block.text !== "") {
+        yield { type: "thinking_delta", text: block.text };
+      }
+    }
+    yield { type: "response", response };
+  }
+};
+
+// src/loop/replay.ts
+async function replaySession(records, tools) {
+  const problems = [];
+  const responses = [];
+  const outcomes = /* @__PURE__ */ new Map();
+  const expectedCalls = [];
+  for (const record of records) {
+    if (record.type === "assistant") {
+      responses.push(record.response);
+      for (const block of record.response.content) {
+        if (block.type === "tool_use") expectedCalls.push(signature(block));
+      }
+    }
+    if (record.type === "compaction" && record.summary !== void 0)
+      responses.push(record.summary);
+    if (record.type === "tool_results" && record.synthetic !== true) {
+      const reports = new Map(record.calls.map((call) => [call.toolUseId, call.subagent]));
+      for (const block of record.message.content) {
+        if (block.type === "tool_result") {
+          const subagent = reports.get(block.toolUseId);
+          outcomes.set(block.toolUseId, {
+            content: block.content,
+            isError: block.isError,
+            // Replay does not run the subagent again; its recorded usage still counts.
+            ...subagent === void 0 ? {} : { subagent }
+          });
+        }
+      }
+    }
+  }
+  const model = new FakeModelClient(responses);
+  const recorded = new RecordedTools(tools, outcomes, problems);
+  const first = records.find((r) => r.type === "start");
+  const session = createSession(first?.root ?? "/replay", first?.sessionId ?? "replay");
+  let limits = first?.limits;
+  let runs = 0;
+  let steps = 0;
+  for (let i = 0; i < records.length; i++) {
+    const record = records[i];
+    if (record === void 0) break;
+    if (record.type === "start" || record.type === "resume" || record.type === "model")
+      limits = record.limits;
+    if (record.type === "snapshot") {
+      pushPoint(session.undo, record.tree, record.messages, record.prompt);
+    } else if (record.type === "undo") {
+      popPoint(session.undo, session.messages, record.after);
+    } else if (record.type === "redo") {
+      redoPoint(session.undo, session.messages);
+    }
+    if (record.type !== "user") continue;
+    const endIndex = records.findIndex((r, j) => j > i && (r.type === "end" || r.type === "user"));
+    const end = endIndex === -1 ? void 0 : records[endIndex];
+    if (end?.type !== "end" || end.stopReason === "interrupted" || end.stopReason === "error") {
+      problems.push(
+        `Run ${runs + 1} did not finish in the recording (it was interrupted). Replay stops there.`
+      );
+      break;
+    }
+    runs++;
+    closeOpenToolCalls(session);
+    const texts = record.message.content.flatMap((b) => b.type === "text" ? [b.text] : []);
+    session.messages.push({ role: "user", content: texts.map((t) => ({ type: "text", text: t })) });
+    const result = await runAgent(session, {
+      model,
+      tools: recorded,
+      system: "replay",
+      permissions: NO_PERMISSIONS,
+      ...limits === void 0 ? {} : {
+        maxSteps: limits.maxSteps,
+        tokenBudget: limits.tokenBudget,
+        contextWindow: limits.contextWindow
+      }
+    });
+    steps += result.steps;
+    if (result.stopReason !== end.stopReason || result.steps !== end.steps) {
+      problems.push(
+        `Run ${runs}: the recording stopped with ${end.stopReason} after ${end.steps} steps; the replay stopped with ${result.stopReason} after ${result.steps} steps.`
+      );
+    }
+    const expected = rebuildState(records.slice(0, endIndex + 1)).messages;
+    if (!isDeepStrictEqual(session.messages, expected)) {
+      problems.push(`Run ${runs}: the conversation differs from the recording.`);
+    }
+  }
+  if (model.remaining > 0)
+    problems.push(`${model.remaining} recorded model responses were not used.`);
+  const actualCalls = recorded.calls;
+  if (problems.length === 0 && !isDeepStrictEqual(actualCalls, expectedCalls.slice(0, actualCalls.length))) {
+    problems.push("The tool calls differ from the recording.");
+  }
+  return { matches: problems.length === 0, runs, steps, toolCalls: actualCalls.length, problems };
+}
+var RecordedTools = class {
+  constructor(real, outcomes, problems) {
+    this.real = real;
+    this.outcomes = outcomes;
+    this.problems = problems;
+  }
+  real;
+  outcomes;
+  problems;
+  calls = [];
+  specs() {
+    return this.real.specs();
+  }
+  isReadOnly(name) {
+    return this.real.isReadOnly(name);
+  }
+  runsCommands(name) {
+    return this.real.runsCommands(name);
+  }
+  async execute(call, _context) {
+    this.calls.push(signature(call));
+    const outcome = this.outcomes.get(call.id);
+    if (outcome !== void 0) return outcome;
+    this.problems.push(`No recorded result for ${call.name} call ${call.id}.`);
+    return { content: "Error: no recorded result.", isError: true };
+  }
+};
+var NO_PERMISSIONS = {
+  check: async () => ({ allowed: false, by: "rule", reason: "Replay runs no tools." }),
+  execPolicy: () => {
+    throw new Error("Replay runs no commands.");
+  },
+  deniedByPolicy: () => true,
+  commandPolicyDenial: () => "Replay runs no commands."
+};
+
+// src/cli/banner.ts
+import { homedir } from "os";
+var WORDMARK = [
+  " \u2588\u2588\u2588\u2588\u2588\u2588   \u2588\u2588\u2588\u2588\u2588  \u2588\u2588\u2588\u2588\u2588\u2588  \u2588\u2588    \u2588\u2588 \u2588\u2588\u2588\u2588\u2588\u2588   \u2588\u2588\u2588\u2588\u2588 ",
+  "\u2588\u2588       \u2588\u2588   \u2588\u2588 \u2588\u2588   \u2588\u2588 \u2588\u2588    \u2588\u2588 \u2588\u2588   \u2588\u2588 \u2588\u2588   \u2588\u2588",
+  "\u2588\u2588   \u2588\u2588\u2588 \u2588\u2588\u2588\u2588\u2588\u2588\u2588 \u2588\u2588\u2588\u2588\u2588\u2588  \u2588\u2588    \u2588\u2588 \u2588\u2588   \u2588\u2588 \u2588\u2588\u2588\u2588\u2588\u2588\u2588",
+  "\u2588\u2588    \u2588\u2588 \u2588\u2588   \u2588\u2588 \u2588\u2588   \u2588\u2588 \u2588\u2588    \u2588\u2588 \u2588\u2588   \u2588\u2588 \u2588\u2588   \u2588\u2588",
+  " \u2588\u2588\u2588\u2588\u2588\u2588  \u2588\u2588   \u2588\u2588 \u2588\u2588   \u2588\u2588  \u2588\u2588\u2588\u2588\u2588\u2588  \u2588\u2588\u2588\u2588\u2588\u2588  \u2588\u2588   \u2588\u2588"
+];
+var WORDMARK_MIN_COLUMNS = 60;
+var FROM = [255, 122, 24];
+var TO = [255, 209, 102];
+function colorLevel(stream = process.stdout, env = process.env) {
+  if (env.NO_COLOR !== void 0 || stream.isTTY !== true || env.TERM === "dumb") return "none";
+  return /truecolor|24bit/i.test(env.COLORTERM ?? "") ? "truecolor" : "basic";
+}
+function banner(info, options) {
+  const c = paint(options.color);
+  const lines = [];
+  if (options.columns >= WORDMARK_MIN_COLUMNS) {
+    const width = WORDMARK[0]?.length ?? 1;
+    for (const row of WORDMARK) lines.push(c.gradient(row, width));
+    lines.push("");
+  }
+  lines.push(...card(info, options, c));
+  const tips = info.ink ? "/help \xB7 Esc stops a task \xB7 \\ then Enter: new line \xB7 Ctrl-G editor \xB7 Ctrl-P commands" : "/help \xB7 Ctrl-C stops a task \xB7 \\ at the end: new line";
+  lines.push(c.dim(` ${tips}`), "");
+  return lines.join("\n");
+}
+function card(info, options, c) {
+  const home = options.home ?? homedir();
+  const folder = info.root === home || info.root.startsWith(`${home}/`) ? `~${info.root.slice(home.length)}` : info.root;
+  const title = `\u2726 Garuda ${info.version} \xB7 a terminal coding agent`;
+  const rows = [
+    ["model", info.model],
+    ["sandbox", info.sandbox],
+    ["folder", folder]
+  ];
+  const hasCategorized = info.subagents !== void 0 && info.subagents.length > 0 || info.agents !== void 0 && info.agents.length > 0 || info.skills !== void 0 && info.skills.length > 0 || info.tools !== void 0 && info.tools.length > 0;
+  if (hasCategorized) {
+    if (info.subagents !== void 0 && info.subagents.length > 0) {
+      rows.push(["subagents", info.subagents.join(" \xB7 ")]);
+    }
+    if (info.agents !== void 0 && info.agents.length > 0) {
+      rows.push(["agents", info.agents.join(" \xB7 ")]);
+    }
+    if (info.skills !== void 0 && info.skills.length > 0) {
+      rows.push(["skills", info.skills.join(" \xB7 ")]);
+    }
+    if (info.tools !== void 0 && info.tools.length > 0) {
+      rows.push(["tools", info.tools.join(" \xB7 ")]);
+    }
+  } else if (info.extras.length > 0) {
+    rows.push(["extras", info.extras.join(" \xB7 ")]);
+  }
+  const maxLabel = Math.max(...rows.map(([label]) => label.length));
+  const labelWidth = Math.max(9, maxLabel + 2);
+  const prefix = 2 + labelWidth;
+  const natural = Math.max(title.length, ...rows.map(([, v]) => prefix + v.length));
+  const inner = Math.max(20, Math.min(natural + 1, options.columns - 4));
+  const cutStart = (text, max) => text.length <= max ? text : `\u2026${text.slice(text.length - max + 1)}`;
+  const border = (left, right) => c.dim(`${left}${"\u2500".repeat(inner + 2)}${right}`);
+  const line = (plain, styled) => `${c.dim("\u2502")} ${styled}${" ".repeat(Math.max(0, inner - plain.length))} ${c.dim("\u2502")}`;
+  const titleText = cutStart(title, inner);
+  const out = [
+    border("\u256D", "\u256E"),
+    line(
+      titleText,
+      titleText.startsWith("\u2726") ? `${c.gold("\u2726")}${c.bold(titleText.slice(1))}` : c.bold(titleText)
+    ),
+    line("", "")
+  ];
+  for (const [label, value] of rows) {
+    const shown = cutStart(value, inner - prefix);
+    const plain = `  ${label.padEnd(labelWidth)}${shown}`;
+    out.push(line(plain, `  ${c.dim(label.padEnd(labelWidth))}${shown}`));
+  }
+  out.push(border("\u2570", "\u256F"));
+  return out;
+}
+function paint(level) {
+  const esc = (code, text, reset) => `\x1B[${code}m${text}\x1B[${reset}m`;
+  if (level === "none") {
+    return { gradient: (t) => t, gold: (t) => t, bold: (t) => t, dim: (t) => t };
+  }
+  const bold = (t) => esc("1", t, "22");
+  const dim = (t) => esc("2", t, "22");
+  if (level === "basic") {
+    return { gradient: (t) => esc("33", t, "39"), gold: (t) => esc("33", t, "39"), bold, dim };
+  }
+  const rgb = ([r, g, b]) => `38;2;${r};${g};${b}`;
+  return {
+    gradient: (text, width) => [...text].map((ch, i) => {
+      if (ch === " ") return ch;
+      const t = width <= 1 ? 0 : i / (width - 1);
+      const mix = FROM.map((f, k) => Math.round(f + ((TO[k] ?? f) - f) * t));
+      return esc(rgb(mix), ch, "39");
+    }).join(""),
+    gold: (t) => esc(rgb(TO), t, "39"),
+    bold,
+    dim
+  };
+}
+
+// src/cli/jsonOutput.ts
+import { randomUUID } from "crypto";
+var OUTPUT_FORMATS = ["text", "json", "stream-json"];
+var JsonOutput = class {
+  constructor(options) {
+    this.options = options;
+    this.started = this.now();
+  }
+  options;
+  started;
+  initDone = false;
+  lastText = "";
+  denials = [];
+  event(event) {
+    if (this.options.verbose) this.options.log.event(event);
+    switch (event.type) {
+      case "step_end":
+        this.lastText = textOf(event.response);
+        this.stream(() => assistantLine(event.response, this.run().model));
+        return;
+      case "tool_result":
+        if (event.outcome.denied === true) {
+          this.denials.push({
+            tool_name: event.call.name,
+            tool_use_id: event.call.id,
+            tool_input: event.call.input
+          });
+        }
+        this.stream(() => ({
+          type: "user",
+          message: {
+            role: "user",
+            content: [
+              {
+                type: "tool_result",
+                tool_use_id: event.call.id,
+                content: event.outcome.content,
+                is_error: event.outcome.isError
+              }
+            ]
+          },
+          parent_tool_use_id: null
+        }));
+        return;
+      case "model_retry":
+        this.stream(() => ({
+          type: "system",
+          subtype: "api_retry",
+          attempt: event.attempt,
+          max_retries: event.maxRetries,
+          retry_delay_ms: event.delayMs,
+          error_status: null,
+          error: "unknown",
+          message: event.reason
+        }));
+        return;
+      case "compaction":
+        this.stream(() => ({
+          type: "system",
+          subtype: "compact_boundary",
+          compact_metadata: {
+            trigger: "auto",
+            pre_tokens: event.result.beforeTokens,
+            post_tokens: event.result.afterTokens
+          }
+        }));
+        return;
+      default:
+        return;
+    }
+  }
+  info(text) {
+    if (this.options.verbose) this.options.log.info(text);
+  }
+  warn(text) {
+    this.options.log.warn(text);
+  }
+  error(text) {
+    this.options.log.error(text);
+  }
+  /** Write the `result` line (and `system/init` first, if no line came yet). */
+  finish(outcome, info) {
+    const line = resultLine(outcome, {
+      ...info,
+      model: this.run().model,
+      durationMs: Math.round(this.now() - this.started),
+      lastText: this.lastText,
+      denials: this.denials
+    });
+    if (this.options.format === "stream-json") this.stream(() => line);
+    else this.writeLine(line);
+  }
+  stream(make) {
+    if (this.options.format !== "stream-json") return;
+    if (!this.initDone) {
+      this.initDone = true;
+      this.writeLine(initLine(this.run()));
+    }
+    this.writeLine(make());
+  }
+  writeLine(line) {
+    this.options.write(
+      JSON.stringify({ ...line, session_id: this.options.sessionId(), uuid: randomUUID() })
+    );
+  }
+  run() {
+    return this.options.runInfo();
+  }
+  now() {
+    return (this.options.now ?? performance.now.bind(performance))();
+  }
+};
+function initLine(info) {
+  return {
+    type: "system",
+    subtype: "init",
+    cwd: info.cwd,
+    tools: info.tools,
+    mcp_servers: info.mcpServers.map((s) => ({ name: s.name, status: mcpStatus(s.state) })),
+    model: info.model,
+    permissionMode: info.permissionMode,
+    slash_commands: info.slashCommands,
+    apiKeySource: info.apiKeySource,
+    output_style: "default",
+    skills: info.skills ?? [],
+    agents: info.agents ?? [],
+    plugins: [],
+    garuda_version: VERSION
+  };
+}
+function mcpStatus(state) {
+  if (state === "connected" || state === "failed") return state;
+  return state === "stopped" ? "failed" : "disabled";
+}
+function assistantLine(response, model) {
+  return {
+    type: "assistant",
+    message: {
+      id: `msg_${randomUUID().replaceAll("-", "")}`,
+      type: "message",
+      role: "assistant",
+      model,
+      content: response.content.map((block) => {
+        switch (block.type) {
+          case "text":
+            return block.citations === void 0 ? { type: "text", text: block.text } : { type: "text", text: block.text, citations: block.citations };
+          case "tool_use":
+            return { type: "tool_use", id: block.id, name: block.name, input: block.input };
+          // Server tool blocks (0.6) as the API gave them, as Claude Code shows them.
+          default:
+            return block.wire;
+        }
+      }),
+      stop_reason: response.stopReason,
+      stop_sequence: null,
+      usage: apiUsage(response.usage)
+    },
+    parent_tool_use_id: null
+  };
+}
+function apiUsage(u) {
+  return {
+    input_tokens: u.inputTokens,
+    cache_creation_input_tokens: u.cacheWriteTokens,
+    cache_read_input_tokens: u.cacheReadTokens,
+    output_tokens: u.outputTokens,
+    ...u.webSearches === void 0 ? {} : { server_tool_use: { web_search_requests: u.webSearches, web_fetch_requests: 0 } }
+  };
+}
+function textOf(response) {
+  return response.content.filter((b) => b.type === "text").map((b) => b.type === "text" ? b.text : "").join("");
+}
+var STOPS = {
+  done: { subtype: "success", terminal: "completed" },
+  // The model stopped by itself; Claude Code reports these as success with the stop_reason.
+  max_tokens: { subtype: "success", terminal: "completed" },
+  refusal: { subtype: "success", terminal: "completed" },
+  max_steps: { subtype: "error_max_turns", terminal: "max_turns" },
+  // Garuda's budget counts tokens, not dollars, so error_max_budget_usd does not fit.
+  token_budget: { subtype: "error_during_execution", terminal: "budget_exhausted" },
+  repeated_calls: { subtype: "error_during_execution" }
+};
+function resultLine(outcome, info) {
+  const result = outcome.kind === "done" ? outcome.result : void 0;
+  const usage = result?.usage ?? {
+    inputTokens: 0,
+    outputTokens: 0,
+    cacheReadTokens: 0,
+    cacheWriteTokens: 0
+  };
+  const stop = result === void 0 ? void 0 : STOPS[result.stopReason];
+  const subtype = stop?.subtype ?? "error_during_execution";
+  const errors = outcome.kind === "error" ? [outcome.message] : outcome.kind === "interrupted" ? ["Interrupted."] : subtype === "success" ? void 0 : [info.stopMessage ?? `Stopped: ${result?.stopReason}`];
+  return {
+    type: "result",
+    subtype,
+    is_error: outcome.kind === "error",
+    duration_ms: info.durationMs,
+    duration_api_ms: Math.round(result?.apiMs ?? 0),
+    num_turns: result?.steps ?? 0,
+    ...subtype === "success" ? { result: info.lastText } : {},
+    stop_reason: result?.modelStopReason ?? null,
+    total_cost_usd: info.totalCostUsd,
+    usage: apiUsage(usage),
+    modelUsage: {
+      [info.model]: {
+        inputTokens: usage.inputTokens,
+        outputTokens: usage.outputTokens,
+        cacheReadInputTokens: usage.cacheReadTokens,
+        cacheCreationInputTokens: usage.cacheWriteTokens,
+        webSearchRequests: usage.webSearches ?? 0,
+        costUSD: info.runCostUsd ?? 0,
+        contextWindow: info.contextWindow,
+        maxOutputTokens: info.maxOutputTokens
+      }
+    },
+    permission_denials: info.denials,
+    ...errors === void 0 ? {} : { errors },
+    ...stop?.terminal === void 0 ? {} : { terminal_reason: stop.terminal }
+  };
+}
+
+// src/cli/repl.ts
+import { createInterface } from "readline";
+async function runRepl(runtime, approver, renderer, sessionPath, exitNow, io = { input: process.stdin, output: process.stderr }, firstInput, notifier) {
+  const history = [];
+  const list = rootLister(runtime.root);
+  const args = new CommandArgs(runtime);
+  const files = rootFiles(runtime.root);
+  const completer = (line) => {
+    const result = complete(line, line.length, {
+      commands: commandNames(runtime),
+      list,
+      args: (command, before) => args.choices(command, before),
+      files
+    });
+    if (result === void 0) return [[], line];
+    const word = line.slice(line.search(/\S*$/));
+    const done = result.text.slice(line.search(/\S*$/));
+    const words = result.candidates.map(
+      (c) => result.lines === true ? c.split("  ")[0] ?? c : c
+    );
+    return [words.length > 0 ? words : [done], word];
+  };
+  const ask = lineSource(io, completer);
+  let lastInterrupt = 0;
+  let first = firstInput;
+  for (; ; ) {
+    void args.refresh();
+    const input = first !== void 0 ? { kind: "line", text: first } : await ask(runtime.mode === "plan" ? "plan\u203A " : "\u203A ", history);
+    first = void 0;
+    if (input.kind === "eof") return;
+    if (input.kind === "interrupt") {
+      if (Date.now() - lastInterrupt < 2e3) return;
+      lastInterrupt = Date.now();
+      renderer.info("Press Ctrl-C again to exit, or type /exit.");
+      continue;
+    }
+    let raw = input.text;
+    while (raw.endsWith("\\")) {
+      const more = await ask("\u2026 ", []);
+      if (more.kind !== "line") break;
+      raw = `${raw.slice(0, -1)}
+${more.text}`;
+    }
+    const text = raw.trim();
+    if (text === "") continue;
+    history.unshift(raw);
+    if (text.startsWith("!") && text.length > 1) {
+      const controller = new AbortController();
+      approver.onInterrupt = () => controller.abort();
+      const stop = () => controller.abort();
+      process.on("SIGINT", stop);
+      try {
+        const result = await runtime.runUserCommand(text.slice(1).trim(), controller.signal);
+        renderer.info(`${result.text}
+(The output goes to the model with your next message.)`);
+      } catch (error) {
+        renderer.warn(controller.signal.aborted ? "Command stopped." : error.message);
+      } finally {
+        process.off("SIGINT", stop);
+        approver.onInterrupt = () => {
+        };
+      }
+      continue;
+    }
+    let prompt = text;
+    if (text.startsWith("/")) {
+      const result = await runCommand(text, { runtime, renderer, sessionPath });
+      if (result === "exit") return;
+      if (result === "done") continue;
+      prompt = result.prompt;
+    }
+    for (; ; ) {
+      const planning = runtime.mode === "plan";
+      const outcome = await runTurnInTerminal(
+        runtime,
+        approver,
+        renderer,
+        prompt,
+        exitNow,
+        notifier
+      );
+      if (!planning || outcome.kind !== "done" || outcome.result.stopReason !== "done") break;
+      if (await planHandoff(runtime, approver) !== "now") break;
+      renderer.info(`\u203A ${BUILD_PROMPT}`);
+      prompt = BUILD_PROMPT;
+    }
+  }
+}
+function lineSource(io, completer) {
+  if (io.input.isTTY === true) {
+    return (prompt, history) => askTerminal(prompt, history, io, completer);
+  }
+  const rl = createInterface({ input: io.input, terminal: false });
+  const queue = [];
+  let waiting;
+  const push = (input) => {
+    if (waiting !== void 0) {
+      const resolve = waiting;
+      waiting = void 0;
+      resolve(input);
+    } else queue.push(input);
+  };
+  rl.on("line", (text) => push({ kind: "line", text }));
+  rl.on("close", () => push({ kind: "eof" }));
+  return (prompt) => {
+    io.output.write(prompt);
+    const next = queue.shift();
+    if (next !== void 0) {
+      if (next.kind === "eof") queue.unshift(next);
+      return Promise.resolve(next);
+    }
+    return new Promise((resolve) => {
+      waiting = resolve;
+    });
+  };
+}
+function askTerminal(prompt, history, io, completer) {
+  return new Promise((resolve) => {
+    const rl = createInterface({
+      input: io.input,
+      output: io.output,
+      terminal: true,
+      history: [...history],
+      historySize: 100,
+      ...completer === void 0 ? {} : { completer }
+    });
+    let done = false;
+    const finish = (input) => {
+      if (done) return;
+      done = true;
+      rl.close();
+      resolve(input);
+    };
+    rl.on("line", (text) => finish({ kind: "line", text }));
+    rl.on("SIGINT", () => {
+      io.output.write("\n");
+      finish({ kind: "interrupt" });
+    });
+    rl.on("close", () => finish({ kind: "eof" }));
+    rl.setPrompt(prompt);
+    rl.prompt();
+  });
+}
+
+// src/cli/index.ts
+async function main() {
+  const program = new Command().enablePositionalOptions().name("garuda").description("A terminal coding agent. With no task, it starts a chat in the current folder.").version(VERSION).option("-p, --prompt <task>", "run one task and exit").option("-m, --model <id>", "model id (or set GARUDA_MODEL)").option(
+    "--subagent-model <id>",
+    "model of the explore subagent (or set GARUDA_SUBAGENT_MODEL); default: the main model"
+  ).option("--plan", "start in plan mode: read and plan, change nothing").option("--lsp", "add language server errors to edit results (TS/JS, Python, Java)").option("-r, --resume [session-id]", "continue the last session, or the given one").option("--replay <session-id-or-file>", "replay a recorded session with no API calls").addOption(
+    new Option("--output-format <format>", "with a task: text (default), json or stream-json").choices(OUTPUT_FORMATS).default("text")
+  ).option("--verbose", "with json output: also show the tool activity on stderr").action(async (options) => {
+    process.exitCode = await start(options, program);
+  });
+  program.command("eval").description("run the eval tasks in scratch folders and report pass/fail, steps and cost").option("-m, --model <id>", "model id (or set GARUDA_MODEL)").option("-s, --suite <name>", "basic (default), hard, java, python, all or repo").option("-t, --task <ids...>", "run only these tasks (from any suite)").option("--max-steps <n>", "step limit per task", (v) => Number.parseInt(v, 10)).option(
+    "--repeat <n>",
+    "run each task n times and show the mean",
+    (v) => Number.parseInt(v, 10)
+  ).option("--index <mode>", "code index tools for the model: off (default), lookup or all").option("--executor <name>", "auto (default), os or host").option("--keep", "keep the scratch folders").option("--list", "list the tasks and exit").option("--subagents <mode>", "the explore subagent: off (default) or on, for A/B runs").option("--subagent-model <id>", "model of the explore subagent; default: the main model").option("--todo <mode>", "the todo_write tool: off (default) or on, for A/B runs").option("--lsp <mode>", "language server errors in edit results: off (default) or on").option(
+    "--format <mode>",
+    "the project's formatter after edits: off (default) or on, for A/B runs"
+  ).option(
+    "--keep-thinking <mode>",
+    "send Claude's thinking blocks back: on (default) or off, for A/B runs"
+  ).option(
+    "--batch <mode>",
+    "model calls through the Batch API (half price, slow): off (default) or on"
+  ).option(
+    "--parallel <n>",
+    "tasks at the same time; default 1, with --batch on all (up to 20)",
+    (v) => Number.parseInt(v, 10)
+  ).option(
+    "--prepare <toolchain>",
+    "java: download Maven plugins and JUnit once; python: check pytest"
+  ).option("--from-git", "build the repo suite from this project's recent commits, then exit").option(
+    "--commits <n>",
+    "with --from-git: recent commits to look at (default 200)",
+    (v) => Number.parseInt(v, 10)
+  ).option("--since <date>", "with --from-git: only commits after this date").option(
+    "--max-tasks <n>",
+    "with --from-git: most tasks in the suite (default 30)",
+    (v) => Number.parseInt(v, 10)
+  ).option(
+    "--network <entries...>",
+    "presets (npm, pypi, maven, go, cargo, github) or hosts that sandboxed commands may reach"
+  ).option(
+    "--test-command <cmd>",
+    "with --from-git: the test command; {files} takes the test files (default: detected)"
+  ).action(async (options) => {
+    const { runEvalCommand } = await import("../evalCommand-3SSFMZQD.js");
+    process.exitCode = await runEvalCommand({
+      ...options,
+      model: options.model ?? process.env.GARUDA_MODEL,
+      subagentModel: options.subagentModel ?? process.env.GARUDA_SUBAGENT_MODEL
+    });
+  });
+  program.command("init").description(
+    "set up this folder (AGENTS.md; commands, MCP servers and rules from Claude Code, OpenCode, Codex, Gemini CLI, Tabnine, Cursor, Copilot), then chat"
+  ).option("-m, --model <id>", "model id (or set GARUDA_MODEL)").action(async (options) => {
+    process.exitCode = await start({ ...options, firstInput: "/init" }, program);
+  });
+  program.command("run").description(
+    "run a scheduled job (made with /schedule) in its own worktree, with its approval list and nobody to ask"
+  ).argument("<job-id>", "the job id, from /schedule or /jobs").option("--at <HH:MM>", "wait until this local time first (keep the terminal open)").option("-m, --model <id>", "model id; default: the job's model").addOption(new Option("--from-launchd").hideHelp()).action(
+    async (job, options) => {
+      process.exitCode = await start({ ...options, job }, program);
+    }
+  );
+  program.command("night").description(
+    "run this project's night queue (jobs from /schedule), up to 3 at a time, then write one digest"
+  ).option("--at <HH:MM>", "wait until this local time first (keep the terminal open)").option("--parallel <n>", "jobs at the same time (1 to 10, default 3)").addOption(new Option("--from-launchd").hideHelp()).action(async (options) => {
+    const { nightCommand } = await import("../nightCommand-CR6ZHYGP.js");
+    process.exitCode = await nightCommand(options, new PlainRenderer());
+  });
+  program.command("acp").description(
+    "run as an agent for an editor over the Agent Client Protocol (VS Code with an extension, Zed, JetBrains, Neovim, Emacs); the editor starts it"
+  ).option("-m, --model <id>", "model id (or set GARUDA_MODEL)").action(async (options) => {
+    const { acpCommand } = await import("../acpCommand-FZ2P5JFO.js");
+    process.exitCode = await acpCommand(options);
+  });
+  const lsp = program.command("lsp").description("show the language servers for diagnostics (TS/JS, Python, Java)").action(async () => {
+    const { lspStatusCommand } = await import("../lspCommand-XNTBHXLA.js");
+    process.exitCode = await lspStatusCommand();
+  });
+  lsp.command("install").description("install a pinned language server into ~/.garuda/lsp (needs the network)").argument("<language>", "typescript, python or java").action(async (language) => {
+    const { lspInstallCommand } = await import("../lspCommand-XNTBHXLA.js");
+    process.exitCode = await lspInstallCommand(language);
+  });
+  await program.parseAsync();
+}
+async function start(options, program) {
+  const mainRoot = realpathSync(process.cwd());
+  const store = new FileSessionStore(mainRoot);
+  if (options.replay !== void 0) return replay(options.replay, store);
+  let job;
+  let jobGuard;
+  if (options.job !== void 0) {
+    const { prepareJob } = await import("../jobCommand-XJ5GULS5.js");
+    const prepared = await prepareJob(
+      mainRoot,
+      options.job,
+      options.at,
+      new PlainRenderer(),
+      void 0,
+      { fromLaunchd: options.fromLaunchd === true },
+      homedir2()
+    );
+    if (typeof prepared === "number") return prepared;
+    job = prepared;
+    const { failJobSync } = await import("../job-3NYDMP2M.js");
+    const preparedJob = prepared;
+    jobGuard = () => {
+      if (preparedJob.job.status === "running") {
+        failJobSync(
+          preparedJob.job,
+          "Garuda stopped before the job's turn finished. The error is in the job's log or on the terminal."
+        );
+      }
+    };
+    process.once("exit", jobGuard);
+  }
+  const root = job?.root ?? mainRoot;
+  let prompt = job?.job.prompt ?? options.prompt;
+  if (prompt === void 0 && !process.stdin.isTTY && job === void 0)
+    prompt = readFileSync(0, "utf8").trim();
+  if (prompt === "") program.error("The task is empty.");
+  const format = options.outputFormat ?? "text";
+  if (format !== "text" && prompt === void 0) {
+    program.error(`--output-format ${format} needs a task: use -p "task" or give it on stdin.`);
+  }
+  const spec = options.model ?? job?.job.model ?? process.env.GARUDA_MODEL;
+  if (!spec) program.error("Set a model with --model <id> or the GARUDA_MODEL variable.");
+  const models = await loadModelsConfig();
+  if (models.problem !== void 0) program.error(models.problem);
+  let resolved;
+  try {
+    resolved = resolveModel(spec, models.config);
+  } catch (error) {
+    program.error(error.message);
+  }
+  const modelId = resolved.spec;
+  const subSpec = options.subagentModel ?? process.env.GARUDA_SUBAGENT_MODEL;
+  let sub;
+  if (subSpec) {
+    try {
+      sub = resolveModel(subSpec, models.config);
+    } catch (error) {
+      program.error(error.message);
+    }
+  }
+  const searchConfig = await loadSearchConfig();
+  const hasApiKey = hasProviderKey("ANTHROPIC_API_KEY");
+  for (const name of [resolved.def.apiKeyEnv, sub?.def.apiKeyEnv, "ANTHROPIC_API_KEY"]) {
+    if (name !== void 0) keepProviderKey(name);
+  }
+  const { loadTeamPolicy } = await import("../policy-EJPLEEXP.js");
+  let team;
+  try {
+    team = await loadTeamPolicy();
+  } catch (error) {
+    program.error(`Team policy: ${error.message}`);
+  }
+  const renderer = new PlainRenderer();
+  const terminalApprover = new TerminalApprover();
+  const approver = new SwitchApprover(
+    job === void 0 ? terminalApprover : new AutoApprover("deny")
+  );
+  let events = renderer;
+  const runtime = await Runtime.create({
+    root,
+    modelId,
+    ...team === void 0 ? {} : { policy: team.policy, policySources: team.sources },
+    // The audit log lives in ~/.garuda/audit, keyed by the project (a job: its main checkout, not
+    // the worktree that is deleted after the job).
+    audit: { dir: auditDirFor(job?.job.root ?? root) },
+    model: job?.job.batch === true && resolved.createBatch !== void 0 ? () => jobBatchClient(job, resolved, renderer) : () => resolved.create(),
+    modelInfo: resolved.info,
+    ...resolved.maxTokens === void 0 ? {} : { maxTokens: resolved.maxTokens },
+    ...sub === void 0 ? {} : { subagentModel: { spec: sub.spec, model: () => sub.create(), info: sub.info } },
+    approver,
+    store,
+    ...job === void 0 ? {} : {
+      settings: job.settings,
+      // The job's network list was approved with the job (0.13).
+      network: { approved: true },
+      unattended: {
+        reason: JOB_DENIAL,
+        onDeny: (tool, target) => recordJobDenial(job, tool, target)
+      }
+    },
+    ...options.plan === true ? { mode: "plan" } : {},
+    ...options.lsp === true ? { lsp: { enabled: true } } : {},
+    // Undo snapshots are on for the chat and for -p (a later chat can undo the task). A job has its
+    // own branch instead.
+    ...job === void 0 ? { undo: {} } : {},
+    // Skills from ~/.garuda/skills, ~/.claude/skills and the project (0.5).
+    skills: {},
+    // User language plugins from ~/.garuda/languages (0.16); project plugins stay off.
+    languages: {},
+    // The project's settings that loosen safety: asked at startup when there is a terminal,
+    // pinned in ~/.garuda/trust.json (a job passes its own settings).
+    projectSettings: { home: homedir2(), ask: process.stdin.isTTY === true },
+    // Web search (0.5) and Claude's own search (0.6): only the user's search.json and environment.
+    ...searchConfig.config === void 0 && searchConfig.claude === void 0 ? {} : {
+      search: {
+        ...searchConfig.config === void 0 ? {} : { config: searchConfig.config },
+        ...searchConfig.claude === void 0 ? {} : { claude: searchConfig.claude },
+        // The saved choice (0.14); the first-time answer is saved in ~/.garuda/search.json.
+        ...searchConfig.use === void 0 ? {} : { use: searchConfig.use },
+        home: homedir2()
+      }
+    },
+    // Custom agents from ~/.garuda/agents, ~/.claude/agents and the project (0.5). A model id in a
+    // user agent file goes through the same providers as -m (only ~/.garuda/models.json).
+    agents: {
+      resolveModel: (spec2) => {
+        const r = resolveModel(spec2, models.config);
+        return { spec: r.spec, model: () => r.create(), info: r.info };
+      }
+    },
+    // /models (0.6): the same providers as -m; the list adds the user's configured models.
+    models: {
+      resolve: (spec2) => {
+        const r = resolveModel(spec2, models.config);
+        return {
+          spec: r.spec,
+          model: () => r.create(),
+          info: r.info,
+          ...r.maxTokens === void 0 ? {} : { maxTokens: r.maxTokens }
+        };
+      },
+      configured: Object.keys(models.config.models)
+    },
+    ...options.resume === void 0 ? {} : { resume: options.resume },
+    onEvent: (event) => events.event(event),
+    onNotice: (text) => events.warn(text)
+  });
+  process.on("exit", () => runtime.executor.shutdown());
+  const exitNow = () => {
+    runtime.executor.shutdown();
+    process.exit(130);
+  };
+  if (runtime.executorNotice !== void 0) renderer.warn(runtime.executorNotice);
+  if (job !== void 0 && runtime.executor.isolation === "none") {
+    renderer.error(
+      "A job needs the OS sandbox (Seatbelt or bubblewrap): without it, every command would need an approval, and nobody is there to give it."
+    );
+    await runtime.close();
+    const { saveJob } = await import("../job-3NYDMP2M.js");
+    job.job.status = "failed";
+    await saveJob(job.job);
+    if (options.fromLaunchd === true || job.job.launchd !== void 0) {
+      const { removeAgent, defaultAgentEnv } = await import("../launchd-QVHQ3VNN.js");
+      await removeAgent(runtime.executor, job.job, defaultAgentEnv());
+    }
+    return 1;
+  }
+  if (searchConfig.problem !== void 0) {
+    renderer.warn(
+      searchConfig.claude === void 0 ? `Web search is off: ${searchConfig.problem}` : `The fallback web search is off (Claude's search still works): ${searchConfig.problem}`
+    );
+  }
+  const session = runtime.session;
+  if (session !== void 0) {
+    renderer.info(
+      `Resumed session ${session.id} (${session.messages.length} messages, ${formatTokens(session.contextTokens)} tokens of context).`
+    );
+  }
+  for (const note of resolved.notes) renderer.info(note);
+  if (runtime.price === void 0) {
+    renderer.warn(
+      `Garuda has no price for ${modelId}. Set "price" for it in ~/.garuda/models.json to see cost.`
+    );
+  }
+  if (prompt !== void 0) {
+    const output = format === "text" ? void 0 : new JsonOutput({
+      format,
+      write: (line) => process.stdout.write(`${line}
+`),
+      // stdout holds only JSON: model text never goes there.
+      log: new PlainRenderer({ out: nullStream(), err: process.stderr }),
+      verbose: options.verbose === true,
+      sessionId: () => runtime.session?.id ?? "",
+      runInfo: () => ({
+        cwd: root,
+        model: modelId,
+        tools: runtime.toolNames(),
+        mcpServers: runtime.mcpStatus(),
+        permissionMode: runtime.mode === "plan" ? "plan" : "default",
+        slashCommands: [
+          ...BUILTIN_COMMANDS,
+          ...runtime.commands.map((c) => c.name),
+          ...runtime.skills.filter((k) => k.userInvocable).map((k) => k.name)
+        ],
+        skills: runtime.skills.map((k) => k.name),
+        agents: runtime.agents.map((a) => a.name),
+        apiKeySource: !modelId.includes("/") && hasApiKey ? "ANTHROPIC_API_KEY" : "none"
+      })
+    });
+    if (output !== void 0) events = output;
+    const costBefore = runtime.session?.costUsd ?? 0;
+    const finish = (outcome2) => {
+      const cost = runtime.session?.costUsd;
+      output?.finish(outcome2, {
+        totalCostUsd: cost ?? 0,
+        runCostUsd: cost === void 0 ? void 0 : cost - costBefore,
+        contextWindow: runtime.limits.contextWindow,
+        maxOutputTokens: resolved.maxTokens ?? DEFAULT_MAX_TOKENS,
+        ...outcome2.kind === "done" ? { stopMessage: stopMessage(outcome2.result.stopReason, runtime.limits) } : {}
+      });
+    };
+    if (prompt.startsWith("/")) {
+      const resolved2 = await runtime.resolveCommand(prompt, new AbortController().signal);
+      if (resolved2.kind === "denied") {
+        (output ?? renderer).warn(resolved2.message);
+        await runtime.close();
+        finish({ kind: "error", message: resolved2.message });
+        return 1;
+      }
+      if (resolved2.kind === "prompt") prompt = resolved2.prompt;
+    }
+    if (job !== void 0) {
+      const { testsBefore } = await import("../jobCommand-XJ5GULS5.js");
+      await testsBefore(job, runtime, renderer);
+    }
+    const outcome = await runTurnInTerminal(
+      runtime,
+      terminalApprover,
+      output ?? renderer,
+      prompt,
+      exitNow
+    );
+    await runtime.close();
+    finish(outcome);
+    if (job !== void 0) {
+      const { finishJob } = await import("../jobCommand-XJ5GULS5.js");
+      await finishJob(job, outcome, runtime, renderer, void 0, {
+        fromLaunchd: options.fromLaunchd === true
+      });
+    }
+    if (outcome.kind === "interrupted") return 130;
+    if (outcome.kind === "error") return 1;
+    return outcome.result.stopReason === "done" ? 0 : 2;
+  }
+  const ink = wantsInk() ? await loadInk(renderer) : void 0;
+  const bannerInfo = {
+    version: VERSION,
+    model: modelId,
+    sandbox: runtime.executor.isolation === "none" ? "none: each command asks first" : `${runtime.executor.name} \xB7 no network`,
+    root,
+    extras: runtime.extras(),
+    subagents: runtime.subagentsSummary(),
+    agents: runtime.agentsSummary(),
+    skills: runtime.skillsSummary(),
+    tools: runtime.toolsSummary(),
+    ink: ink !== void 0
+  };
+  let startBanner = banner(bannerInfo, {
+    columns: process.stdout.columns || 80,
+    color: colorLevel(process.stdout)
+  });
+  if (options.firstInput === void 0) {
+    const { initTip } = await import("../detect-LARDSLLZ.js");
+    const tip = initTip(root);
+    if (tip !== void 0) startBanner += `
+${tip}`;
+  }
+  const sessionPath = (id2) => join(store.dir, `${id2}.jsonl`);
+  const notify = runtime.notificationSettings;
+  const channel = pickChannel(notify?.channel);
+  const focus = ink !== void 0 && channel !== "off" && reportsFocus() ? new FocusTracker() : void 0;
+  if (focus !== void 0) process.on("exit", () => process.stdout.write(FOCUS_REPORTING_OFF));
+  const notifier = process.stdout.isTTY ? new Notifier(
+    channel,
+    (bytes) => process.stdout.write(bytes),
+    notify?.afterSeconds,
+    () => focus?.focused
+  ) : void 0;
+  if (notifier !== void 0) approver.onAsk = (request) => notifier.approval(request);
+  if (ink !== void 0) {
+    const setEventTarget = (target) => {
+      events = target;
+    };
+    await ink.runInkChat(
+      runtime,
+      approver,
+      setEventTarget,
+      startBanner,
+      sessionPath,
+      exitNow,
+      options.firstInput,
+      notifier,
+      focus
+    );
+  } else {
+    process.stderr.write(`${startBanner}
+`);
+    await runRepl(
+      runtime,
+      terminalApprover,
+      renderer,
+      sessionPath,
+      exitNow,
+      void 0,
+      options.firstInput,
+      notifier
+    );
+  }
+  await runtime.close();
+  const id = runtime.session?.id;
+  if (id !== void 0) renderer.info(`Session ${id}. Continue it with: garuda --resume ${id}`);
+  return 0;
+}
+function nullStream() {
+  return new Writable({ write: (_chunk, _encoding, done) => done() });
+}
+function wantsInk() {
+  return process.stdin.isTTY === true && process.stdout.isTTY === true && process.env.GARUDA_PLAIN !== "1" && process.env.TERM !== "dumb";
+}
+async function loadInk(renderer) {
+  try {
+    return await import("../inkChat-34BTFG2K.js");
+  } catch (error) {
+    renderer.info(`Plain chat (Ink is not available: ${error.message.split("\n")[0]}).`);
+    return void 0;
+  }
+}
+async function replay(target, store) {
+  const records = existsSync(target) ? parseRecords(readFileSync(target, "utf8")) : await store.read(target);
+  const report = await replaySession(records, new ToolRegistry(defaultTools({ daemons: true })));
+  const summary = `${report.runs} run(s), ${report.steps} step(s), ${report.toolCalls} tool call(s)`;
+  if (report.matches) {
+    process.stdout.write(`Replay matches the recording: ${summary}.
+`);
+    return 0;
+  }
+  process.stdout.write(`Replay does not match the recording (${summary}):
+`);
+  for (const problem of report.problems) process.stdout.write(`  - ${problem}
+`);
+  return 1;
+}
+main().catch((error) => {
+  process.stderr.write(`Error: ${describeError(error)}
+`);
+  process.exitCode = 1;
+});
+function recordJobDenial(job, tool, target) {
+  const shown = target.kind === "path" ? target.path : target.kind === "command" ? target.command.split("\n")[0] ?? "" : target.kind === "url" ? target.host : target.json.slice(0, 200);
+  job.denied.push({ tool, target: shown });
+}
+async function jobBatchClient(job, resolved, renderer) {
+  const { DeadlineClient } = await import("../deadline-F5RJJ2QW.js");
+  const { nextTime } = await import("../launchd-QVHQ3VNN.js");
+  const { DEFAULT_FINISH_BY, DEFAULT_STEP_LIMIT_MINUTES, SWITCH_BEFORE_MS } = await import("../create-N4I7TIZE.js");
+  const finishBy = job.job.finishBy ?? DEFAULT_FINISH_BY;
+  const stepLimit = job.job.stepLimitMinutes ?? DEFAULT_STEP_LIMIT_MINUTES;
+  const switchAt = new Date(nextTime(finishBy).getTime() - SWITCH_BEFORE_MS);
+  const batch = await resolved.createBatch(
+    process.env,
+    {
+      // A quiet terminal must not look stuck: the batch id, then a line every minute.
+      onWait: ({ batchId, waitedMs, status }) => renderer.info(
+        waitedMs === 0 ? `Waiting for batch ${batchId} \u2026` : `  still waiting for ${batchId}: ${Math.round(waitedMs / 6e4)} min (${status})`
+      )
+    }
+  );
+  job.deadline = new DeadlineClient(batch, () => resolved.create(), switchAt, {
+    stepLimitMs: stepLimit * 6e4
+  });
+  const when = switchAt.toLocaleString(void 0, {
+    weekday: "short",
+    day: "numeric",
+    month: "short",
+    hour: "2-digit",
+    minute: "2-digit"
+  });
+  renderer.info(
+    `Batch API (half price) until ${when}, then the normal API. A step that waits more than ${stepLimit} min runs on the normal API.`
+  );
+  return job.deadline;
+}
+//# sourceMappingURL=index.js.map