@rallycry/conveyor-agent 10.8.1 → 10.9.0

package/dist/{chunk-LBMFXTIV.js → chunk-H3OGNJS4.js}

@@ -951,6 +951,19 @@ var AgentConnection = class _AgentConnection {
     }).catch(() => {
     });
   }
+  /**
+   * The session's key hit a hard usage cap — ask the server to stamp it
+   * limited and hand back the best remaining key's credential env (or a
+   * requeue confirmation when none is left). Awaited: the caller swaps
+   * credentials and resumes on success, so it needs the real response.
+   */
+  async cycleCodingAgentKey(rateLimitType, resetsAt) {
+    return await this.call("cycleCodingAgentKey", {
+      sessionId: this.config.sessionId,
+      rateLimitType,
+      ...resetsAt ? { resetsAt } : {}
+    });
+  }
   // ── Question handling ──────────────────────────────────────────────
   async askUserQuestion(questions) {
     const questionText = questions.map(
@@ -2175,6 +2188,11 @@ var SubmitCodeReviewResultRequestSchema = z.object({
   approved: z.boolean(),
   content: z.string()
 });
+var CycleCodingAgentKeyRequestSchema = z.object({
+  sessionId: z.string(),
+  rateLimitType: z.string(),
+  resetsAt: z.string().optional()
+});
 var StartChildCloudBuildRequestSchema = z.object({
   sessionId: z.string(),
   childTaskId: z.string()
@@ -2726,7 +2744,7 @@ var ModeController = class {
   }
   get isBuildCapable() {
     const m = this.effectiveMode;
-    return m === "building" || m === "review" || m === "auto" && this._hasExitedPlanMode;
+    return m === "building" || m === "review" || m === "chat" || m === "auto" && this._hasExitedPlanMode;
   }
   /**
    * Apply authoritative mode from the server's task context.
@@ -3375,6 +3393,36 @@ var JsonlTailer = class {
   }
 };
 
+// src/harness/pty/limit-banner.ts
+var BANNER_RE = /you'?(?:ve| have) (?:hit|reached) your ([\w-]+ )?(?:usage )?limit/i;
+var RESET_RE = /resets?\s+(\d{1,2})(?::(\d{2}))?\s*(am|pm)\s*\(UTC\)/i;
+function nextUtcOccurrenceSeconds(hour12, minute, meridiem, nowMs) {
+  let hour = hour12 % 12;
+  if (meridiem.toLowerCase() === "pm") hour += 12;
+  const candidate = new Date(nowMs);
+  candidate.setUTCHours(hour, minute, 0, 0);
+  if (candidate.getTime() <= nowMs) candidate.setUTCDate(candidate.getUTCDate() + 1);
+  return Math.floor(candidate.getTime() / 1e3);
+}
+function matchUsageLimitBanner(text, now = Date.now()) {
+  const banner = BANNER_RE.exec(text);
+  if (!banner) return null;
+  const qualifier = banner[1]?.trim().toLowerCase();
+  const rateLimitType = qualifier === "weekly" ? "seven_day" : "five_hour";
+  const reset = RESET_RE.exec(text);
+  return {
+    rateLimitType,
+    ...reset ? {
+      resetsAtEpochSeconds: nextUtcOccurrenceSeconds(
+        Number(reset[1]),
+        reset[2] ? Number(reset[2]) : 0,
+        reset[3],
+        now
+      )
+    } : {}
+  };
+}
+
 // src/harness/pty/chat-record-mapper.ts
 var TEXT_MAX = 16e3;
 var TOOL_INPUT_MAX = 1900;
@@ -4095,6 +4143,14 @@ async function readRaw(path4) {
     return null;
   }
 }
+async function readCredentialsIdentity() {
+  const parsed = parseClaudeAiOauth(await readRaw(claudeCredentialsPath()));
+  if (!parsed) return null;
+  return {
+    accessToken: typeof parsed.accessToken === "string" ? parsed.accessToken : null,
+    hasRefreshToken: typeof parsed.refreshToken === "string" && parsed.refreshToken.length > 0
+  };
+}
 var READ_BACK_DELAYS_MS = [250, 500, 1e3, 2e3];
 var defaultSleep = (ms) => new Promise((resolve) => {
   setTimeout(resolve, ms);
@@ -4563,6 +4619,7 @@ var PtySession = class {
   pty = null;
   tempDir = "";
   sawResult = false;
+  limitBannerReported = false;
   // Rolling tail of raw PTY output, retained only to enrich the error when the
   // CLI exits before emitting a result (the bytes are otherwise relayed to S5
   // and never become events). Trimmed to MAX_DIAGNOSTIC_OUTPUT on every write.
@@ -5093,6 +5150,7 @@ var PtySession = class {
       this.disarmPlanDialogAutoAccept();
     }
     if (this.pendingSubmitNudge) this.disarmSubmitNudge();
+    this.synthesizeRateLimitFromBanner(event);
     this.pushEvent(event);
     if (event.type === "result") {
       this.sawResult = true;
@@ -5100,6 +5158,35 @@ var PtySession = class {
       this.endTurn(true);
     }
   }
+  /**
+   * The interactive CLI reports a hard usage cap only as a conversation banner
+   * ("You've hit your weekly limit · resets 7am (UTC)") — it never writes a
+   * structured rate_limit_event to the transcript. Recognize the banner in
+   * assistant/result text and push the same harness-level event the SDK
+   * harness emits, so cap handling (key cycle → pause) is one code path.
+   * Once per session: the CLI repeats the banner on every rejected turn.
+   */
+  synthesizeRateLimitFromBanner(event) {
+    if (this.limitBannerReported) return;
+    let text;
+    if (event.type === "assistant") {
+      text = event.message.content.map((block) => block.text ?? "").filter(Boolean).join("\n");
+    } else if (event.type === "result" && event.subtype === "success") {
+      text = event.result;
+    }
+    if (!text) return;
+    const match = matchUsageLimitBanner(text);
+    if (!match) return;
+    this.limitBannerReported = true;
+    this.pushEvent({
+      type: "rate_limit_event",
+      rate_limit_info: {
+        status: "rejected",
+        rateLimitType: match.rateLimitType,
+        ...match.resetsAtEpochSeconds === void 0 ? {} : { resetsAt: match.resetsAtEpochSeconds }
+      }
+    });
+  }
   async finalizeOnExit(exitCode) {
     this.coalescer?.flush();
     this.exited = true;
@@ -6104,10 +6191,30 @@ function buildModePrompt(agentMode, context, runnerMode) {
       return buildReviewPrompt(context);
     case "auto":
       return buildAutoPrompt(context, runnerMode);
+    case "chat":
+      return buildChatPrompt();
     default:
       return null;
   }
 }
+function buildChatPrompt() {
+  return [
+    `
+## Mode: Chat`,
+    `You are in Chat mode \u2014 a conversational assistant working directly with the user on this card.`,
+    `- Respond conversationally to the user in chat. Ask clarifying questions when useful; this is a back-and-forth, not an autonomous build.`,
+    `- You have full read/write access to the workspace and can run non-destructive shell commands, so you CAN create files (notes, scripts, docs, data, diagrams, etc.) when they help the user.`,
+    ``,
+    `### Deliverables \u2014 attach, do NOT open a PR`,
+    `- This card has NO pull-request workflow. Do NOT run \`git push\`, do NOT open a PR, and do NOT rely on branch commits to deliver work \u2014 those operations are blocked.`,
+    `- When you create a file the user should keep, attach it to the card with the \`upload_attachment\` tool so it shows up on the card. Mention in chat what you attached.`,
+    ``,
+    `### Finishing the conversation`,
+    `- When the user indicates they are done (or explicitly asks to wrap up / close the card), call \`force_update_task_status\` with status \`"Complete"\` to move the card InProgress \u2192 Done. There is no review or PR step.`,
+    `- If the user is still engaged, keep the card InProgress and keep helping \u2014 only complete it once the interaction has concluded.`,
+    `- Do not complete the card while you still owe the user a response or an attachment.`
+  ].join("\n");
+}
 function buildReviewPrompt(context) {
   const parts = [
     `
@@ -7980,16 +8087,20 @@ function buildConveyorTools(connection, config, context, agentMode) {
   const effectiveMode = agentMode ?? context?.agentMode ?? void 0;
   const commonTools = buildCommonTools(connection, config);
   const modeTools = getModeTools(effectiveMode, connection, config, context);
-  const discoveryTools = effectiveMode === "discovery" || effectiveMode === "auto" || effectiveMode === "building" ? buildDiscoveryTools(connection) : [];
+  const discoveryTools = effectiveMode === "discovery" || effectiveMode === "auto" || effectiveMode === "building" || effectiveMode === "chat" ? buildDiscoveryTools(connection) : [];
   const codeReviewTools = effectiveMode === "review" ? buildCodeReviewTools(connection) : [];
   const emergencyTools = [buildForceUpdateTaskStatusTool(connection)];
-  return withAlwaysLoad([
+  const tools = withAlwaysLoad([
     ...commonTools,
     ...modeTools,
     ...discoveryTools,
     ...codeReviewTools,
     ...emergencyTools
   ]);
+  if (effectiveMode === "chat") {
+    return tools.filter((tool2) => tool2.name !== "create_pull_request");
+  }
+  return tools;
 }
 function createConveyorMcpServer(harness, connection, config, context, agentMode) {
   return harness.createMcpServer({
@@ -8411,6 +8522,13 @@ async function processResultCase(event, host, context, startTime, state) {
   if (info.staleSession) state.staleSession = true;
   if (info.authError) state.authError = true;
 }
+function processRateLimitCase(event, host, state) {
+  const resetsAt = handleRateLimitEvent(event, host);
+  if (resetsAt) state.rateLimitResetsAt = resetsAt;
+  if (event.rate_limit_info.status === "rejected") {
+    state.rateLimitRejectedType = event.rate_limit_info.rateLimitType ?? "unknown";
+  }
+}
 async function processEvents(events, context, host) {
   const startTime = Date.now();
   let lastStatusEmit = Date.now();
@@ -8422,6 +8540,7 @@ async function processEvents(events, context, host) {
     sawApiError: false,
     resultSummary: void 0,
     rateLimitResetsAt: void 0,
+    rateLimitRejectedType: void 0,
     staleSession: void 0,
     authError: void 0,
     lastAssistantUsage: void 0,
@@ -8451,11 +8570,9 @@ async function processEvents(events, context, host) {
       case "result":
         await processResultCase(event, host, context, startTime, state);
         break;
-      case "rate_limit_event": {
-        const resetsAt = handleRateLimitEvent(event, host);
-        if (resetsAt) state.rateLimitResetsAt = resetsAt;
+      case "rate_limit_event":
+        processRateLimitCase(event, host, state);
         break;
-      }
       case "tool_progress":
         handleToolProgressEvent(event, host);
         break;
@@ -8467,11 +8584,38 @@ async function processEvents(events, context, host) {
     retriable: state.retriable || state.sawApiError,
     resultSummary: state.resultSummary,
     rateLimitResetsAt: state.rateLimitResetsAt,
+    ...state.rateLimitRejectedType && { rateLimitRejectedType: state.rateLimitRejectedType },
     ...state.staleSession && { staleSession: state.staleSession },
     ...state.authError && { authError: state.authError }
   };
 }
 
+// src/execution/key-cycle.ts
+var FIVE_HOURS_MS = 5 * 60 * 60 * 1e3;
+var TWENTY_FOUR_HOURS_MS = 24 * 60 * 60 * 1e3;
+function applyCycledKeyEnv(envVars, env = process.env) {
+  for (const [key, value] of Object.entries(envVars)) {
+    env[key] = value;
+  }
+  if (envVars.CLAUDE_CODE_OAUTH_TOKEN) {
+    delete env.ANTHROPIC_API_KEY;
+    if (!envVars.CONVEYOR_AGENT_KEY) delete env.CONVEYOR_AGENT_KEY;
+  } else if (envVars.CONVEYOR_AGENT_KEY || envVars.CONVEYOR_OPENCODE_OAUTH) {
+    delete env.CLAUDE_CODE_OAUTH_TOKEN;
+  }
+}
+async function syncCredentialsAfterCycle(env = process.env) {
+  if (env.CLAUDE_CODE_OAUTH_TOKEN) {
+    await ensureClaudeCredentials(env);
+  } else {
+    await removeConveyorCredentials();
+  }
+}
+function fallbackResetIso(rateLimitType, now = Date.now()) {
+  const weekly = /weekly|seven_day/i.test(rateLimitType);
+  return new Date(now + (weekly ? TWENTY_FOUR_HOURS_MS : FIVE_HOURS_MS)).toISOString();
+}
+
 // src/execution/task-property-utils.ts
 function collectMissingProps(taskProps) {
   const missing = [];
@@ -8541,6 +8685,19 @@ function handleBuildingToolAccess(toolName, input) {
 function handleReviewToolAccess(toolName, input) {
   return handleBuildingToolAccess(toolName, input);
 }
+var CHAT_BLOCKED_BASH = /\bgit\s+push\b|\bgh\s+pr\b|\bhub\s+pull-request\b/;
+function handleChatToolAccess(toolName, input) {
+  if (toolName === "Bash") {
+    const cmd = String(input.command ?? "");
+    if (CHAT_BLOCKED_BASH.test(cmd)) {
+      return {
+        behavior: "deny",
+        message: "Chat mode does not open pull requests. Create files locally and attach them to the card with upload_attachment instead of pushing a branch or opening a PR."
+      };
+    }
+  }
+  return handleBuildingToolAccess(toolName, input);
+}
 function handleAutoToolAccess(toolName, input, hasExitedPlanMode, isParentTask) {
   if (hasExitedPlanMode) {
     return isParentTask ? handleReviewToolAccess(toolName, input) : handleBuildingToolAccess(toolName, input);
@@ -8675,6 +8832,8 @@ function resolveToolAccess(host, toolName, input) {
       return handleReviewToolAccess(toolName, input);
     case "auto":
       return handleAutoToolAccess(toolName, input, host.hasExitedPlanMode, host.isParentTask);
+    case "chat":
+      return handleChatToolAccess(toolName, input);
     default:
       return { behavior: "allow", updatedInput: input };
   }
@@ -8694,6 +8853,12 @@ function buildCanUseTool(host) {
     if (toolName === "AskUserQuestion") {
       return await handleAskUserQuestion(host, input);
     }
+    if (host.agentMode === "chat" && /(^|__)create_pull_request$/.test(toolName)) {
+      return {
+        behavior: "deny",
+        message: 'Chat mode does not open pull requests. When the conversation is complete, mark the card done with force_update_task_status("Complete").'
+      };
+    }
     const result = resolveToolAccess(host, toolName, input);
     if (result.behavior === "deny") {
       consecutiveDenials++;
@@ -9294,6 +9459,48 @@ function handleRateLimitPause(host, rateLimitResetsAt) {
     `Rate limited. The task will be automatically re-queued and resume after ${new Date(rateLimitResetsAt).toLocaleString()}.`
   );
 }
+var MAX_KEY_CYCLES = 5;
+async function handleUsageCapRejection(context, host, options, rateLimitType, resetsAt) {
+  const pauseAt = resetsAt ?? fallbackResetIso(rateLimitType);
+  if (host.keyCycleCount >= MAX_KEY_CYCLES) {
+    handleRateLimitPause(host, pauseAt);
+    return;
+  }
+  host.keyCycleCount += 1;
+  let response;
+  try {
+    response = await host.connection.cycleCodingAgentKey(rateLimitType, resetsAt);
+  } catch (error) {
+    host.connection.postChatMessage(
+      `Usage cap hit and key cycling failed (${getErrorMessage(error)}) \u2014 pausing until ${new Date(pauseAt).toLocaleString()}.`
+    );
+    handleRateLimitPause(host, pauseAt);
+    return;
+  }
+  if (!response.cycled) {
+    handleRateLimitPause(host, response.resetsAt);
+    return;
+  }
+  applyCycledKeyEnv(response.envVars);
+  await syncCredentialsAfterCycle();
+  await host.harness.dispose?.();
+  host.connection.postChatMessage(
+    `Usage cap hit \u2014 switched to key **${response.label}** and resuming.`
+  );
+  context.claudeSessionId = null;
+  host.connection.storeSessionId("");
+  const freshPrompt = buildMultimodalPrompt(
+    await buildInitialPrompt(host.config.mode, context, host.isAuto, host.agentMode),
+    context,
+    host.harnessKind === "pty"
+  );
+  const freshQuery = host.harness.executeQuery({
+    prompt: host.createInputStream(freshPrompt),
+    options: { ...options, sessionId: void 0 },
+    resume: void 0
+  });
+  return runWithRetry(freshQuery, context, host, options);
+}
 function handleRetryError(error, context, host, options, prevImageError) {
   if (isStaleOrExitedSession(error, context) && context.claudeSessionId) {
     return handleStaleSession(context, host, options);
@@ -9306,9 +9513,17 @@ function handleRetryError(error, context, host, options, prevImageError) {
 }
 function handleProcessResult(result, context, host, options) {
   if (result.modeRestart || host.isStopped()) return { action: "return" };
-  if (result.rateLimitResetsAt) {
-    handleRateLimitPause(host, result.rateLimitResetsAt);
-    return { action: "return" };
+  if (result.rateLimitRejectedType || result.rateLimitResetsAt) {
+    return {
+      action: "return_promise",
+      promise: handleUsageCapRejection(
+        context,
+        host,
+        options,
+        result.rateLimitRejectedType ?? "unknown",
+        result.rateLimitResetsAt
+      )
+    };
   }
   if (result.staleSession && context.claudeSessionId) {
     return { action: "return_promise", promise: handleStaleSession(context, host, options) };
@@ -9391,6 +9606,7 @@ var QueryBridge = class {
   _discoveryCompleted = false;
   _isParentTask = false;
   _wasRateLimited = false;
+  _keyCycleCount = 0;
   _abortController = null;
   /** Called by SessionRunner when ExitPlanMode triggers a mode transition. */
   onModeTransition;
@@ -9568,6 +9784,12 @@ var QueryBridge = class {
       set wasRateLimited(val) {
         bridge._wasRateLimited = val;
       },
+      get keyCycleCount() {
+        return bridge._keyCycleCount;
+      },
+      set keyCycleCount(val) {
+        bridge._keyCycleCount = val;
+      },
       get activeQuery() {
         return bridge.activeQuery;
       },
@@ -9651,11 +9873,21 @@ function normalizeUsageText(stdout) {
 }
 function parseUsageGauges(stdout) {
   const text = normalizeUsageText(stdout);
-  const session = text.match(/Current session[^%\n]*?(\d+(?:\.\d+)?)\s*%(?:\s*used)?/i);
-  const weekly = [...text.matchAll(/Current week[^%\n]*?(\d+(?:\.\d+)?)\s*%(?:\s*used)?/gi)];
+  const rows = [
+    ...text.matchAll(
+      /Current (session|week)\s*(\([^)\n]*\))?[^%\n]*?(\d+(?:\.\d+)?)\s*%(?:\s*used)?/gi
+    )
+  ];
+  const gauges = rows.map((m) => ({
+    label: `Current ${m[1].toLowerCase()}${m[2] ? ` ${m[2]}` : ""}`,
+    utilization: Number(m[3]) / 100
+  }));
+  const session = gauges.find((g) => g.label.startsWith("Current session"));
+  const weekly = gauges.filter((g) => g.label.startsWith("Current week"));
   return {
-    sessionUsage: session ? Number(session[1]) / 100 : null,
-    weeklyUsage: weekly.length ? Math.max(...weekly.map((m) => Number(m[1]))) / 100 : null
+    sessionUsage: session ? session.utilization : null,
+    weeklyUsage: weekly.length ? Math.max(...weekly.map((g) => g.utilization)) : null,
+    gauges
   };
 }
 
@@ -9768,17 +10000,44 @@ async function runUsageProbe(deps = {}) {
 
 // src/execution/usage-sampler.ts
 var logger4 = createServiceLogger("usage-sampler");
-async function sampleKeyUsage(token, probe = () => runUsageProbe(), hasSubscriptionCredentials = () => existsSync3(claudeCredentialsPath())) {
+function isAttributable(identity, sessionToken) {
+  if (!identity) return { ok: true };
+  if (identity.hasRefreshToken) {
+    return { ok: false, reason: "manual-login-credentials" };
+  }
+  if (sessionToken && identity.accessToken && identity.accessToken !== sessionToken) {
+    return { ok: false, reason: "credentials-token-mismatch" };
+  }
+  return { ok: true };
+}
+async function sampleKeyUsage(token, probe = () => runUsageProbe(), hasSubscriptionCredentials = () => existsSync3(claudeCredentialsPath()), readIdentity = readCredentialsIdentity) {
   if (!token && !hasSubscriptionCredentials()) return [];
   try {
+    const attributable = isAttributable(await readIdentity(), token);
+    if (!attributable.ok) {
+      logger4.info("usage sample skipped \u2014 credentials not attributable to this session's key", {
+        reason: attributable.reason
+      });
+      return [];
+    }
     const stdout = await probe();
-    const { sessionUsage, weeklyUsage } = parseUsageGauges(stdout);
+    const { sessionUsage, weeklyUsage, gauges } = parseUsageGauges(stdout);
     const samples = [];
     if (sessionUsage !== null) {
-      samples.push({ rateLimitType: "five_hour", utilization: sessionUsage, status: "allowed" });
+      samples.push({
+        rateLimitType: "five_hour",
+        utilization: sessionUsage,
+        status: "allowed",
+        gauges
+      });
     }
     if (weeklyUsage !== null) {
-      samples.push({ rateLimitType: "seven_day", utilization: weeklyUsage, status: "allowed" });
+      samples.push({
+        rateLimitType: "seven_day",
+        utilization: weeklyUsage,
+        status: "allowed",
+        gauges
+      });
     }
     if (samples.length === 0) {
       logger4.info("usage sample produced no gauges", {
@@ -10173,7 +10432,7 @@ function isHeavyGateActive() {
 }
 
 // src/runner/session-runner.ts
-var AUTO_RUN_MODES = /* @__PURE__ */ new Set(["building", "auto", "review", "discovery"]);
+var AUTO_RUN_MODES = /* @__PURE__ */ new Set(["building", "auto", "review", "discovery", "chat"]);
 var SessionRunner = class _SessionRunner {
   connection;
   mode;
@@ -10744,7 +11003,8 @@ var SessionRunner = class _SessionRunner {
         type: "rate_limit_update",
         rateLimitType: sample.rateLimitType,
         utilization: sample.utilization,
-        status: sample.status
+        status: sample.status,
+        gauges: sample.gauges
       });
     }
   }
@@ -11281,4 +11541,4 @@ export {
   runStartCommand,
   unshallowRepo
 };
-//# sourceMappingURL=chunk-LBMFXTIV.js.map
+//# sourceMappingURL=chunk-H3OGNJS4.js.map