@rallycry/conveyor-agent 9.0.3 → 10.0.0

package/dist/{chunk-EYIGNRRW.js → chunk-34NA4BCK.js}

@@ -378,6 +378,14 @@ var AgentConnection = class _AgentConnection {
   static RECONNECT_MAX_DELAY_MS = 6e4;
   static RECONNECT_STATUS_EVERY_N = 3;
   isReconnecting = false;
+  /**
+   * Invoked after every successful session reconnect (the `connectAgent` RPC
+   * re-established the session room). The runner uses this to force a TUI
+   * repaint: the reconnect may have landed on a different/restarted API
+   * process whose PTY scrollback ring is empty, and a quiet terminal would
+   * otherwise never re-seed it.
+   */
+  onReconnected;
   async reconnectToSession() {
     if (this.isReconnecting) return;
     this.isReconnecting = true;
@@ -409,6 +417,10 @@ var AgentConnection = class _AgentConnection {
             reason: "reconnected",
             attempts: attempt
           });
+          try {
+            this.onReconnected?.();
+          } catch {
+          }
           return;
         } catch (err) {
           const errMsg = err instanceof Error ? err.message : String(err);
@@ -541,24 +553,23 @@ var AgentConnection = class _AgentConnection {
     };
   }
   // ── Convenience methods (thin wrappers around call / emit) ─────────
-  async emitStatus(status) {
+  async emitStatus(status, reason) {
     this.lastEmittedStatus = status;
     await this.flushEvents();
+    const payload = {
+      sessionId: this.config.sessionId,
+      status,
+      ...reason ? { reason } : {}
+    };
     const AWAIT_STATUSES = ["idle", "waiting_for_input", "connected"];
     if (AWAIT_STATUSES.includes(status)) {
       try {
-        await this.call("reportAgentStatus", {
-          sessionId: this.config.sessionId,
-          status
-        });
+        await this.call("reportAgentStatus", payload);
         this.lastReportedStatus = status;
       } catch {
       }
     } else {
-      void this.call("reportAgentStatus", {
-        sessionId: this.config.sessionId,
-        status
-      }).then(() => {
+      void this.call("reportAgentStatus", payload).then(() => {
         this.lastReportedStatus = status;
       }).catch(() => {
       });
@@ -668,17 +679,6 @@ var AgentConnection = class _AgentConnection {
     this.sendEvent({ type: "agent_typing_stop" });
   }
   // ── RPC convenience wrappers (v6 compat, will migrate to call()) ───
-  trackSpending(params) {
-    if (!this.socket) return;
-    void this.call("trackSpending", {
-      sessionId: this.config.sessionId,
-      inputTokens: params.modelUsage?.reduce((s, m) => s + (m.inputTokens ?? 0), 0) ?? 0,
-      outputTokens: params.modelUsage?.reduce((s, m) => s + (m.outputTokens ?? 0), 0) ?? 0,
-      costUsd: params.totalCostUsd,
-      model: params.modelUsage?.[0]?.model ?? "unknown"
-    }).catch(() => {
-    });
-  }
   emitRateLimitPause(resetsAt) {
     this.sendEvent({ type: "rate_limit_update", resetsAt });
   }
@@ -723,9 +723,6 @@ ${q.question}${q.options.length ? "\n" + q.options.map((o) => `- ${o.label}: ${o
   triggerIdentification() {
     return this.call("triggerIdentification", { sessionId: this.config.sessionId });
   }
-  getCumulativeSpending() {
-    return this.call("getCumulativeSpending", { sessionId: this.config.sessionId });
-  }
   async refreshAuthToken() {
     const result = await this.refreshFromBootstrap();
     return result.refreshedClaude;
@@ -1287,6 +1284,7 @@ const net = require("node:net");
 const crypto = require("node:crypto");
 
 const PRE_TOOL_USE_TIMEOUT_MS = 110000;
+const ASK_USER_QUESTION_TIMEOUT_MS = 5000;
 
 let raw = "";
 process.stdin.setEncoding("utf8");
@@ -1358,17 +1356,26 @@ function preToolUse(payload) {
     );
     process.exit(0);
   };
-  const denyUnavailable = () =>
-    respond(
-      "deny",
-      "Conveyor validation is unavailable right now. Wait a moment and call the tool again.",
-    );
+  // AskUserQuestion is observe-only (status reporting) \u2014 fail OPEN so a
+  // missing/slow socket never denies the questionnaire. Everything else
+  // (ExitPlanMode) is a Conveyor gate \u2014 fail CLOSED.
+  const failOpen = payload.tool_name === "AskUserQuestion";
+  const respondUnavailable = () =>
+    failOpen
+      ? respond("allow")
+      : respond(
+          "deny",
+          "Conveyor validation is unavailable right now. Wait a moment and call the tool again.",
+        );
   if (!socketPath) {
-    denyUnavailable();
+    respondUnavailable();
     return;
   }
   const id = crypto.randomBytes(8).toString("hex");
-  const timer = setTimeout(denyUnavailable, PRE_TOOL_USE_TIMEOUT_MS);
+  const timer = setTimeout(
+    respondUnavailable,
+    failOpen ? ASK_USER_QUESTION_TIMEOUT_MS : PRE_TOOL_USE_TIMEOUT_MS,
+  );
   const client = net.connect(socketPath, () => {
     client.write(
       JSON.stringify({
@@ -1403,11 +1410,11 @@ function preToolUse(payload) {
   });
   client.on("error", () => {
     clearTimeout(timer);
-    denyUnavailable();
+    respondUnavailable();
   });
   client.on("close", () => {
     clearTimeout(timer);
-    denyUnavailable();
+    respondUnavailable();
   });
 }
 `;
@@ -1445,6 +1452,13 @@ async function writeHookSettings(dir) {
         {
           matcher: "ExitPlanMode",
           hooks: [{ type: "command", command: `node ${JSON.stringify(helperPath)}`, timeout: 120 }]
+        },
+        {
+          // Observe-only: lets the session report waiting_for_input the moment
+          // the planning questionnaire renders. The helper fails open for this
+          // tool, so the questionnaire is never blocked by Conveyor.
+          matcher: "AskUserQuestion",
+          hooks: [{ type: "command", command: `node ${JSON.stringify(helperPath)}`, timeout: 30 }]
         }
       ],
       PostToolUse: [
@@ -1682,7 +1696,9 @@ var ConnectAgentRequestSchema = z.object({
 });
 var ReportAgentStatusRequestSchema = z.object({
   sessionId: z.string(),
-  status: z.string()
+  status: z.string(),
+  /** Why the agent reports this status (e.g. "user_question" while an AskUserQuestion questionnaire is pending in the TUI). */
+  reason: z.string().optional()
 });
 var NotifyAgentVersionRequestSchema = z.object({
   sessionId: z.string(),
@@ -1997,6 +2013,20 @@ var GetProjectTaskSessionsRequestSchema = z2.object({
   projectId: z2.string(),
   taskId: z2.string()
 });
+var QueryProjectGcpLogsRequestSchema = z2.object({
+  projectId: z2.string(),
+  env: z2.enum(["prod", "dev", "claudespace"]).optional(),
+  severity: z2.enum(["DEBUG", "INFO", "NOTICE", "WARNING", "ERROR", "CRITICAL", "ALERT", "EMERGENCY"]).optional(),
+  services: z2.array(z2.string().min(1).max(200)).max(25).optional(),
+  sqlInstances: z2.array(z2.string().min(1).max(200)).max(25).optional(),
+  allServices: z2.boolean().optional(),
+  search: z2.string().max(256).optional(),
+  filter: z2.string().max(1e3).optional(),
+  startTime: z2.string().optional(),
+  endTime: z2.string().optional(),
+  limit: z2.number().int().min(1).max(200).optional().default(50),
+  pageToken: z2.string().max(4096).optional()
+});
 var StartProjectBuildRequestSchema = z2.object({
   projectId: z2.string(),
   taskId: z2.string(),
@@ -2175,6 +2205,7 @@ var CreateProjectSuggestionRequestSchema = z2.object({
   tagNames: z2.array(z2.string()).optional(),
   requestingUserId: z2.string().optional()
 });
+var AGENT_STATUS_REASON_USER_QUESTION = "user_question";
 var TASK_CHAT_HISTORY_LIMIT = 20;
 var PM_CHAT_HISTORY_LIMIT = 40;
 var AGENT_CHAT_HISTORY_FETCH_LIMIT = Math.max(TASK_CHAT_HISTORY_LIMIT, PM_CHAT_HISTORY_LIMIT) + 10;
@@ -3107,6 +3138,25 @@ async function transcriptSize(path) {
     return 0;
   }
 }
+function parseUserQuestions(input) {
+  if (!Array.isArray(input.questions)) return [];
+  const questions = [];
+  for (const entry of input.questions) {
+    if (!isRecord2(entry)) continue;
+    if (typeof entry.question !== "string") continue;
+    const options = Array.isArray(entry.options) ? entry.options.filter(isRecord2).filter((o) => typeof o.label === "string").map((o) => ({
+      label: o.label,
+      description: typeof o.description === "string" ? o.description : ""
+    })) : [];
+    questions.push({
+      question: entry.question,
+      header: typeof entry.header === "string" ? entry.header : "",
+      options,
+      ...typeof entry.multiSelect === "boolean" ? { multiSelect: entry.multiSelect } : {}
+    });
+  }
+  return questions;
+}
 var PtySession = class {
   constructor(prompt, options, resume, bridge) {
     this.prompt = prompt;
@@ -3222,6 +3272,21 @@ var PtySession = class {
     } catch {
     }
   }
+  /**
+   * Force the CLI to repaint its full screen by wiggling the pty size
+   * (SIGWINCH). Used after a socket reconnect: the server's scrollback ring is
+   * per-process and starts empty on a new instance, so without a repaint a
+   * quiet TUI would leave the Connected-TUI terminal blank (and hidden) until
+   * the CLI next draws on its own.
+   */
+  forceRepaint() {
+    if (!this.pty) return;
+    try {
+      this.pty.resize(this.cols, Math.max(1, this.rows - 1));
+      this.pty.resize(this.cols, this.rows);
+    } catch {
+    }
+  }
   async teardown() {
     if (this._toreDown) return;
     this._toreDown = true;
@@ -3384,11 +3449,17 @@ var PtySession = class {
   }
   /**
    * PreToolUse request from the hook helper → the runner's `canUseTool`
-   * verdict. Only ExitPlanMode is matched by the settings hook, so this is
-   * the Conveyor plan-exit gate (validation + identification trigger run
-   * inside the callback). Absent callback → allow (mirrors the SDK default).
+   * verdict. ExitPlanMode is the Conveyor plan-exit gate (validation +
+   * identification trigger run inside the callback); AskUserQuestion is
+   * observed and always allowed. Absent callback → allow (mirrors the SDK
+   * default).
    */
   async handlePreToolUse(request) {
+    if (request.tool_name === "AskUserQuestion") {
+      this.disarmSubmitNudge();
+      this.queue.push({ type: "user_question", questions: parseUserQuestions(request.tool_input) });
+      return { decision: "allow" };
+    }
     const canUseTool = this.options.canUseTool;
     let verdict;
     if (canUseTool) {
@@ -3635,6 +3706,17 @@ var PtyHarness = class {
     this.bridge = bridge;
   }
   bridge;
+  /** The session currently streaming events, if any — repaint target. */
+  activeSession = null;
+  /**
+   * Wiggle the live pty's size so the CLI repaints its whole screen. No-op
+   * between queries or on the SDK harness. Called after a socket reconnect so
+   * the server's (per-process, possibly brand-new) scrollback ring re-seeds
+   * and the Connected-TUI terminal reappears.
+   */
+  forceRepaint() {
+    this.activeSession?.forceRepaint();
+  }
   async *executeQuery(opts) {
     const session = new PtySession(
       opts.prompt,
@@ -3645,11 +3727,13 @@ var PtyHarness = class {
     await ensureClaudeCredentials();
     await ensureClaudeOnboarding(process.env, opts.options.cwd);
     await session.start();
+    this.activeSession = session;
     try {
       for await (const event of session.events()) {
         yield event;
       }
     } finally {
+      if (this.activeSession === session) this.activeSession = null;
       await session.teardown();
     }
   }
@@ -5004,7 +5088,7 @@ var cliEventFormatters = {
   tool_result: (e) => `${e.tool} \u2192 ${e.output?.slice(0, 500) ?? ""}${e.isError ? " [ERROR]" : ""}`,
   message: (e) => e.content ?? "",
   error: (e) => `ERROR: ${e.message ?? ""}`,
-  completed: (e) => `Completed: ${e.summary ?? ""} (cost: $${e.costUsd ?? "?"}, duration: ${e.durationMs ?? "?"}ms)`,
+  completed: (e) => `Completed: ${e.summary ?? ""} (duration: ${e.durationMs ?? "?"}ms)`,
   setup_output: (e) => `[${e.stream ?? "stdout"}] ${e.data ?? ""}`,
   start_command_output: (e) => `[${e.stream ?? "stdout"}] ${e.data ?? ""}`,
   turn_end: (e) => `Turn complete (${e.toolCalls?.length ?? 0} tool calls)`
@@ -6268,35 +6352,16 @@ function emitContextUpdate(modelUsage, host, context, lastAssistantUsage) {
     });
   }
 }
-function trackCostSpending(host, context, cumulativeTotal) {
-  if (cumulativeTotal > 0 && context.agentId && context._runnerSessionId) {
-    const breakdown = host.costTracker.modelBreakdown;
-    host.connection.trackSpending({
-      agentId: context.agentId,
-      sessionId: context._runnerSessionId,
-      totalCostUsd: cumulativeTotal,
-      onSubscription: host.config.mode === "pm" || !!process.env.CLAUDE_CODE_OAUTH_TOKEN,
-      modelUsage: breakdown.length > 0 ? breakdown : void 0
-    });
-  }
-}
 function handleSuccessResult(event, host, context, startTime, lastAssistantUsage) {
   const durationMs = Date.now() - startTime;
   const summary = event.result || "Task completed.";
   const retriable = isRetriableMessage(summary);
-  const cumulativeTotal = host.costTracker.addQueryCost(event.total_cost_usd);
+  host.connection.sendEvent({ type: "completed", summary, durationMs });
   const { modelUsage } = event;
-  if (modelUsage && typeof modelUsage === "object") {
-    host.costTracker.addModelUsage(
-      modelUsage
-    );
-  }
-  host.connection.sendEvent({ type: "completed", summary, costUsd: cumulativeTotal, durationMs });
   if (modelUsage && typeof modelUsage === "object") {
     emitContextUpdate(modelUsage, host, context, lastAssistantUsage);
   }
-  trackCostSpending(host, context, cumulativeTotal);
-  return { totalCostUsd: cumulativeTotal, retriable };
+  return { retriable };
 }
 function handleErrorResult(event, host) {
   const errorMsg = event.errors.length > 0 ? event.errors.join(", ") : `Agent stopped: ${event.subtype}`;
@@ -6325,7 +6390,7 @@ function handleResultEvent(event, host, context, startTime, lastAssistantUsage)
     return { ...result2, resultSummary };
   }
   const result = handleErrorResult(event, host);
-  return { totalCostUsd: 0, ...result, resultSummary };
+  return { ...result, resultSummary };
 }
 async function emitResultEvent(event, host, context, startTime, lastAssistantUsage) {
   const result = handleResultEvent(event, host, context, startTime, lastAssistantUsage);
@@ -6336,7 +6401,6 @@ async function emitResultEvent(event, host, context, startTime, lastAssistantUsa
     await host.callbacks.onEvent({
       type: "completed",
       summary,
-      costUsd: result.totalCostUsd,
       durationMs
     });
   } else if (!result.staleSession) {
@@ -6456,6 +6520,44 @@ async function handleResultCase(event, host, context, startTime, isTyping, lastA
 }
 
 // src/execution/event-processor.ts
+function hasAskUserQuestionBlock(event) {
+  return event.message.content.some((b) => b.type === "tool_use" && b.name === "AskUserQuestion");
+}
+async function armQuestionPending(host, state) {
+  state.questionPending = true;
+  await host.connection.emitStatus("waiting_for_input", AGENT_STATUS_REASON_USER_QUESTION);
+  await host.callbacks.onStatusChange("waiting_for_input");
+}
+async function clearQuestionPending(host, state, options) {
+  if (!state.questionPending) return;
+  state.questionPending = false;
+  if (options.emitRunning) {
+    await host.connection.emitStatus("running");
+    await host.callbacks.onStatusChange("running");
+  }
+}
+async function applyQuestionTransitions(event, host, state) {
+  switch (event.type) {
+    case "user_question":
+      await armQuestionPending(host, state);
+      return;
+    case "assistant":
+      if (!hasAskUserQuestionBlock(event)) {
+        await clearQuestionPending(host, state, { emitRunning: true });
+      }
+      return;
+    case "tool_progress":
+      if (event.tool_name === "AskUserQuestion") {
+        await clearQuestionPending(host, state, { emitRunning: true });
+      }
+      return;
+    case "result":
+      await clearQuestionPending(host, state, { emitRunning: false });
+      return;
+    default:
+      break;
+  }
+}
 function stopTypingIfNeeded(host, isTyping) {
   if (isTyping) host.connection.sendTypingStop();
 }
@@ -6535,13 +6637,14 @@ async function processEvents(events, context, host) {
     staleSession: void 0,
     authError: void 0,
     lastAssistantUsage: void 0,
-    turnToolCalls: []
+    turnToolCalls: [],
+    questionPending: false
   };
   for await (const event of events) {
     if (host.isStopped()) break;
     flushPendingToolCalls(host, state.turnToolCalls);
     const now = Date.now();
-    if (now - lastStatusEmit >= STATUS_REEMIT_INTERVAL_MS) {
+    if (now - lastStatusEmit >= STATUS_REEMIT_INTERVAL_MS && !state.questionPending) {
       host.connection.emitStatus("running");
       lastStatusEmit = now;
     }
@@ -6549,6 +6652,7 @@ async function processEvents(events, context, host) {
       stopTypingIfNeeded(host, state.isTyping);
       return { retriable: false, modeRestart: true };
     }
+    await applyQuestionTransitions(event, host, state);
     switch (event.type) {
       case "system":
         await processSystemCase(event, host, context, state);
@@ -7051,7 +7155,6 @@ function buildQueryOptions(host, context) {
     effort: settings.effort,
     thinking: settings.thinking,
     betas: settings.betas,
-    maxBudgetUsd: settings.maxBudgetUsd ?? 50,
     abortController: host.abortController ?? void 0,
     disallowedTools: buildDisallowedTools(settings, mode, host.hasExitedPlanMode),
     enableFileCheckpointing: settings.enableFileCheckpointing,
@@ -7450,58 +7553,6 @@ async function runWithRetry(initialQuery, context, host, options) {
   }
 }
 
-// src/execution/cost-tracker.ts
-var CostTracker = class {
-  cumulativeCostUsd = 0;
-  modelUsage = /* @__PURE__ */ new Map();
-  seeded = false;
-  /**
-   * Rehydrate cumulative spend from the server so `maxBudgetUsd` enforcement
-   * accounts for costs incurred by prior agent runs on the same task. Must be
-   * called before any `addQueryCost` / `addModelUsage` — re-seeding after
-   * costs have accumulated would clobber in-process totals.
-   */
-  seed(totalCostUsd, modelUsage) {
-    if (this.seeded) return;
-    if (this.cumulativeCostUsd > 0 || this.modelUsage.size > 0) return;
-    this.cumulativeCostUsd = totalCostUsd;
-    for (const entry of modelUsage) {
-      this.modelUsage.set(entry.model, { ...entry });
-    }
-    this.seeded = true;
-  }
-  /** Add cost from a completed query and return the running total */
-  addQueryCost(queryCostUsd) {
-    this.cumulativeCostUsd += queryCostUsd;
-    return this.cumulativeCostUsd;
-  }
-  /** Merge per-model usage from a completed query */
-  addModelUsage(usage) {
-    for (const [model, data] of Object.entries(usage)) {
-      const existing = this.modelUsage.get(model) ?? {
-        model,
-        inputTokens: 0,
-        outputTokens: 0,
-        cacheReadInputTokens: 0,
-        cacheCreationInputTokens: 0,
-        costUSD: 0
-      };
-      existing.inputTokens += data.inputTokens ?? 0;
-      existing.outputTokens += data.outputTokens ?? 0;
-      existing.cacheReadInputTokens += data.cacheReadInputTokens ?? 0;
-      existing.cacheCreationInputTokens += data.cacheCreationInputTokens ?? 0;
-      existing.costUSD += data.costUSD ?? 0;
-      this.modelUsage.set(model, existing);
-    }
-  }
-  get totalCostUsd() {
-    return this.cumulativeCostUsd;
-  }
-  get modelBreakdown() {
-    return [...this.modelUsage.values()];
-  }
-};
-
 // src/execution/exploration-tracker.ts
 var FILE_REREAD_NUDGE_L1 = 3;
 var FILE_REREAD_NUDGE_L2 = 5;
@@ -7628,7 +7679,6 @@ var QueryBridge = class {
       harnessKind,
       harnessKind === "pty" ? buildPtyBridge(connection) : void 0
     );
-    this.costTracker = new CostTracker();
     this.planSync = new PlanSync(workspaceDir, connection);
   }
   connection;
@@ -7639,7 +7689,6 @@ var QueryBridge = class {
   /** Which harness drives this bridge ("pty" task chat; "sdk" only under the
    *  CONVEYOR_FORCE_SDK_CARDS maintainer override). */
   harnessKind;
-  costTracker;
   planSync;
   sessionIds = /* @__PURE__ */ new Map();
   activeQuery = null;
@@ -7671,6 +7720,13 @@ var QueryBridge = class {
   get wasRateLimited() {
     return this._wasRateLimited;
   }
+  /**
+   * Ask the live terminal (PTY harness only) to redraw its full screen.
+   * Safe no-op on the SDK harness or between queries.
+   */
+  forceRepaint() {
+    this.harness.forceRepaint?.();
+  }
   stop() {
     this._stopped = true;
     this._abortController?.abort();
@@ -7678,10 +7734,6 @@ var QueryBridge = class {
   resume() {
     this._stopped = false;
   }
-  /** Rehydrate CostTracker from server-side cumulative spend on agent boot. */
-  seedCostTracker(totalCostUsd, modelUsage) {
-    this.costTracker.seed(totalCostUsd, modelUsage);
-  }
   /**
    * How the INITIAL instructions for this task would be delivered — "prefill"
    * means the TUI input is pre-filled but unsubmitted, awaiting the human.
@@ -7740,7 +7792,6 @@ var QueryBridge = class {
       harness: this.harness,
       harnessKind: this.harnessKind,
       setupLog: [],
-      costTracker: this.costTracker,
       explorationTracker: bridge.mode.effectiveMode === "discovery" || bridge.mode.effectiveMode === "auto" && !bridge.mode.hasExitedPlanMode ? new ExplorationTracker(bridge._isParentTask) : null,
       sessionIds: this.sessionIds,
       pendingToolOutputs: this.pendingToolOutputs,
@@ -8050,7 +8101,6 @@ var SessionRunner = class _SessionRunner {
       });
     }
     this.queryBridge = this.createQueryBridge();
-    await this.seedCostTrackerFromServer();
     this.logInitialization();
     const staleBatch = [...this.pendingMessages];
     const didExecuteInitialQuery = await this.executeInitialMode();
@@ -8602,6 +8652,7 @@ var SessionRunner = class _SessionRunner {
     this.connection.onMessage((msg) => this.injectMessage(msg));
     this.connection.onStop(() => this.stop());
     this.connection.onSoftStop(() => this.softStop());
+    this.connection.onReconnected = () => this.queryBridge?.forceRepaint();
     this.connection.onModeChange((data) => {
       const action = this.mode.handleModeChange(data.agentMode);
       if (action.type === "start_auto") {
@@ -8634,36 +8685,6 @@ var SessionRunner = class _SessionRunner {
       handlePullBranch(this.config.workspaceDir, branch);
     });
   }
-  /**
-   * Rehydrate CostTracker from server. Caps at 3s so a slow API call never
-   * blocks agent startup — on timeout/error we fall through with a $0 tracker
-   * (the existing behavior before this rehydration path was added).
-   */
-  async seedCostTrackerFromServer() {
-    if (!this.queryBridge) return;
-    const TIMEOUT_MS = 3e3;
-    try {
-      const timeout = new Promise((resolve) => {
-        setTimeout(() => resolve(null), TIMEOUT_MS);
-      });
-      const fetched = await Promise.race([this.connection.getCumulativeSpending(), timeout]);
-      if (fetched) {
-        this.queryBridge.seedCostTracker(fetched.totalCostUsd, fetched.modelUsage);
-        process.stderr.write(
-          `[conveyor-agent] CostTracker seeded: $${fetched.totalCostUsd.toFixed(4)} across ${fetched.modelUsage.length} model(s)
-`
-        );
-      } else {
-        process.stderr.write(
-          "[conveyor-agent] CostTracker seed timed out after 3s \u2014 starting at $0\n"
-        );
-      }
-    } catch (err) {
-      const msg = err instanceof Error ? err.message : String(err);
-      process.stderr.write(`[conveyor-agent] CostTracker seed failed: ${msg} \u2014 starting at $0
-`);
-    }
-  }
   /** Proactively refresh the GitHub token before the 1-hour expiry. */
   async refreshGithubToken() {
     try {
@@ -8893,4 +8914,4 @@ export {
   runStartCommand,
   unshallowRepo
 };
-//# sourceMappingURL=chunk-EYIGNRRW.js.map
+//# sourceMappingURL=chunk-34NA4BCK.js.map