@bivy/bivy 0.17.3-staging.7 → 0.17.3-staging.9

package/dist/apps/inspector.js

@@ -33,15 +33,30 @@ const selector=el=>{
   return parts.join(' > ')||el.localName;
 };
 let box=null,target=null,onPicked=post,host=null;
-const stop=()=>{box?.remove();box=null;target=null;removeEventListener('pointermove',hover,true);removeEventListener('click',pick,true);removeEventListener('keydown',key,true);};
+// Picks on pointerup: iOS never fires click for a tap on a non-clickable
+// element when only window listens, so click would miss most of the page.
+// While pointing, the app sees none of the gesture, including the click after.
+const SWALLOW=['pointerdown','mousedown','mouseup','touchend','click','dblclick','contextmenu'];
+const swallow=e=>{e.preventDefault();e.stopPropagation();};
+// A second listener, so stopping (which the shell does right after a pick)
+// doesn't also drop the guard on the rest of the tap. The tap's click ends it.
+const aftermath=e=>{swallow(e);if(e.type==='click')listen(false,aftermath);};
+const listen=(on,handler=swallow)=>{
+  const method=on?addEventListener:removeEventListener;
+  if(handler===swallow){method('pointermove',hover,true);method('pointerup',pick,true);method('keydown',key,true);}
+  for(const type of SWALLOW)method(type,handler,true);
+};
+const stop=()=>{box?.remove();box=null;target=null;listen(false);};
 const hover=e=>{
   const el=document.elementFromPoint(e.clientX,e.clientY);
   if(!el||el===box||el===host)return;target=el;const r=el.getBoundingClientRect();
   Object.assign(box.style,{left:r.left+'px',top:r.top+'px',width:r.width+'px',height:r.height+'px'});
 };
 const pick=e=>{
-  e.preventDefault();e.stopPropagation();
+  swallow(e);
   const el=document.elementFromPoint(e.clientX,e.clientY)||target;stop();
+  // Keep eating the click (and iOS's delayed mouse events) this tap still fires.
+  listen(true,aftermath);setTimeout(()=>listen(false,aftermath),500);
   if(!el||el===host){onPicked({type:'picked',cancelled:true});return;}const r=el.getBoundingClientRect();
   onPicked({type:'picked',selector:selector(el),tag:el.localName,text:(el.innerText||el.getAttribute('aria-label')||el.getAttribute('alt')||'').trim().replace(/\\s+/g,' ').slice(0,200),
     rect:{x:Math.round(r.left),y:Math.round(r.top),width:Math.round(r.width),height:Math.round(r.height)},
@@ -54,7 +69,7 @@ function startPointing(){
   box.setAttribute('aria-hidden','true');
   Object.assign(box.style,{position:'fixed',zIndex:2147483647,pointerEvents:'none',outline:'2px solid Highlight',outlineOffset:'2px',borderRadius:'4px',transition:'all 60ms ease-out'});
   document.documentElement.append(box);
-  addEventListener('pointermove',hover,true);addEventListener('click',pick,true);addEventListener('keydown',key,true);
+  listen(true);
 }
 addEventListener('message',e=>{
   if(!framed||e.origin!==SHELL||e.source!==parent||e.data?.type!=='bivy:point')return;

package/dist/apps/styles.css

@@ -551,6 +551,8 @@ input, textarea, select { font-family: inherit; font-size: 16px; }
 .hljs-addition { color: var(--syntax-addition); }
 .msg.system { align-self: center; color: var(--muted); font-size: 13px; font-style: italic; display: flex; flex-direction: column; align-items: center; gap: 8px; text-align: center; }
 .msg.system .system-text { display: block; }
+.entry-actions { display: flex; flex-wrap: wrap; gap: var(--space-2); font-style: normal; }
+.msg.system .entry-actions { justify-content: center; }
 .msg.thinking { align-self: flex-start; color: var(--muted); font-size: 13px; border-left: 2px solid var(--line-strong); padding-left: 10px; }
 .msg.error {
   align-self: stretch; display: flex; gap: 8px; align-items: flex-start;

package/dist/policy/session-limit.js

@@ -0,0 +1,63 @@
+// SPDX-License-Identifier: AGPL-3.0-only
+// Copyright (c) 2026 Petter André Sjulstad
+//
+// Session limit recovery — the user-driven counterpart to the policy's automatic
+// resume (session-reroute.ts planResume).
+//
+// When a turn ends because the agent hit a provider usage/rate limit and no
+// ruleset recovered it automatically, the session shouldn't just show a dead
+// error. This decides whether the failure IS such a limit, and what the user can
+// do about it: fork the work to another agent right away, or opt in to retrying
+// the same prompt automatically once the window resets. The caller (server.ts)
+// surfaces the offer as a notice with action buttons and, when the user accepts
+// the retry, schedules it through the same durable resume machinery the
+// automatic path uses.
+import { classifyFailure } from "./conditions.js";
+/** The conditions a user can route around (fork) or wait out (retry at reset),
+ *  with how the notice describes each. Adding a limit-like condition is a row. */
+const LIMIT_COPY = {
+    credits_exhausted: "reached its usage limit",
+    rate_limited: "is being rate-limited",
+};
+/** Retry a little after the stated reset: providers round reset times and a
+ *  re-send that lands a few seconds early just hits the same limit again. */
+const RESET_GRACE_MS = 60_000;
+/** Classify a turn error; returns the limit it represents, or undefined when it
+ *  is some other failure. `resetsAtHint` is the provider's structured reset time
+ *  (see ClassifyOptions) and wins over anything scraped from the text. */
+export function detectSessionLimit(error, opts = {}) {
+    const now = opts.now ?? Date.now();
+    const classified = classifyFailure(error, { now, resetsAtHint: opts.resetsAtHint });
+    if (!LIMIT_COPY[classified.condition])
+        return undefined;
+    const resetsAt = classified.resetsAt
+        ?? (classified.retryAfterMs !== undefined ? new Date(now + classified.retryAfterMs).toISOString() : undefined);
+    return { condition: classified.condition, ...(resetsAt ? { resetsAt } : {}) };
+}
+/** The notice offering the user a way past the limit. Actions are client
+ *  action ids: `fork` opens the fork sheet; `retry-at-reset:<iso>` opts in to an
+ *  automatic retry (the timestamp is only for the button's label — the daemon
+ *  schedules from its own remembered limit). */
+export function sessionLimitNotice(agentName, limit) {
+    const what = `${agentName} ${LIMIT_COPY[limit.condition] ?? "hit a limit"}.`;
+    return limit.resetsAt
+        ? {
+            message: `${what} Fork to another agent to keep going, or retry automatically when the limit resets.`,
+            actions: ["fork", `retry-at-reset:${limit.resetsAt}`],
+        }
+        : { message: `${what} Fork to another agent to keep going.`, actions: ["fork"] };
+}
+/** A resume plan for a user who opted in to retrying at reset. Undefined when
+ *  the reset time is unknown. A reset already in the past retries shortly. */
+export function limitResumePlan(limit, now = Date.now()) {
+    const reset = limit.resetsAt ? Date.parse(limit.resetsAt) : NaN;
+    if (!Number.isFinite(reset))
+        return undefined;
+    const dueMs = Math.max(reset, now) + RESET_GRACE_MS;
+    return {
+        condition: limit.condition,
+        summary: `${limit.condition}: retrying when the limit resets at ${limit.resetsAt}.`,
+        delayMs: dueMs - now,
+        resumeAt: new Date(dueMs).toISOString(),
+    };
+}

package/dist/protocol/client-command-schemas.js

@@ -42,6 +42,7 @@ export const CLIENT_COMMAND_SCHEMAS = {
     "session.rename": Type.Object({ ...session, name: Type.String() }),
     abort: Type.Object(optionalSession),
     "session.turn_attention.resolve": Type.Object({ ...session, action: Type.Union([Type.Literal("stop"), Type.Literal("continue")]) }),
+    "session.limit_retry": Type.Object({ ...session, enabled: Type.Boolean() }),
     "session.command.invoke": Type.Object({ ...session, name: Type.String(), args: Type.Optional(Type.String()) }),
     "branches.list": Type.Object({ repo: Type.String() }),
     "history": Type.Object({ ...request, ...optionalSession, have: Type.Optional(Type.Number()), haveToken: Type.Optional(Type.String()) }),

package/dist/server.js

@@ -16,6 +16,7 @@ import { listRuntimes, catalogRuntimes, agentInstallSpec, canonicalAgentId, inva
 import { createRunPolicy } from "./policy/run-policy.js";
 import { DEFAULT_BACKOFF } from "./policy/ruleset.js";
 import { SessionRerouteController } from "./policy/session-reroute.js";
+import { detectSessionLimit, limitResumePlan, sessionLimitNotice } from "./policy/session-limit.js";
 import { activeRulesetFor } from "./runtime/ruleset-store.js";
 import { createRulesetController } from "./controllers/rulesets.js";
 import { createAuditLog, readAuditEvents } from "./audit/index.js";
@@ -2215,6 +2216,11 @@ const RELAY_COMMANDS = {
         else
             abortSessionRecord(record, ctx.broadcast);
     },
+    "session.limit_retry"(msg) {
+        const record = resolveSession(msg.sessionId);
+        if (record)
+            setSessionLimitRetry(record, msg.enabled === true);
+    },
     "session.turn_attention.resolve"(msg) {
         const record = resolveSession(msg.sessionId);
         const action = msg.action === "stop" ? "stop" : msg.action === "continue" ? "continue" : undefined;
@@ -2927,6 +2933,7 @@ const RELAY_COMMANDS = {
             // The user is driving this turn manually — supersede any pending auto-resume
             // that was scheduled after a prior limit so it can't re-fire on top of them.
             clearSessionResume(record.id);
+            record.limitHit = undefined;
             await turnWatchdog.promptWithWatchdog(record, agentPrompt, record.lastPromptOptions);
         }).catch((error) => {
             // Mirror the HTTP path (see the /prompt route): a rejected turn after
@@ -7274,12 +7281,15 @@ function scheduleSessionResume(record, plan) {
     metadata.setResumeAt(record.id, plan.resumeAt);
     metadata.setResumeAttempts(record.id, attempts + 1);
     const when = Date.parse(plan.resumeAt);
-    const cond = plan.condition.replace(/_/g, " ");
+    const at = Number.isFinite(when)
+        ? new Date(when).toLocaleString("en-US", { timeZone: "UTC", month: "short", day: "numeric", hour: "2-digit", minute: "2-digit", hour12: false })
+        : plan.resumeAt;
     broadcast({
         type: "session.notice",
         sessionId: record.id,
         level: "info",
-        message: `Hit a ${cond} limit — I'll resume this automatically when it resets (${plan.resumeAt}).`,
+        message: `I'll retry this automatically when the limit resets (${at} UTC).`,
+        actions: ["cancel-resume"],
     });
     armSessionResumeTimer(record.id, Number.isFinite(when) ? when : Date.now());
     return true;
@@ -7318,6 +7328,23 @@ async function driveSessionResume(id) {
         console.warn(`[resume] auto-resume after a provider limit failed for ${id}`, error);
     }
 }
+/** The user's answer to a surfaced limit: opt in to retrying the turn when the
+ *  window resets (scheduled through the same durable resume path the policy
+ *  uses), or cancel a pending retry. */
+function setSessionLimitRetry(record, enabled) {
+    if (!enabled) {
+        clearSessionResume(record.id);
+        metadata.setResumeAttempts(record.id, 0);
+        broadcast({ type: "session.notice", sessionId: record.id, level: "info", message: "Automatic retry cancelled." });
+        return;
+    }
+    const plan = record.limitHit && limitResumePlan(record.limitHit);
+    if (!plan) {
+        broadcast({ type: "session.notice", sessionId: record.id, level: "info", message: "There's no pending limit to retry — send a message to continue." });
+        return;
+    }
+    scheduleSessionResume(record, plan);
+}
 /** Re-arm (or immediately fire) durable auto-resume markers. Runs once at boot
  *  and on an interval, so a wait survives a restart and a capped timer's tail
  *  still fires. */
@@ -7646,6 +7673,13 @@ function attachSessionListeners(record) {
                 broadcast({ type: "session.failed", sessionId: record.id, failedAt: record.lastFailureAt });
                 if (messageError)
                     broadcast({ type: "session.error", sessionId: record.id, error: sessionAgentError(record, messageError) });
+                // A usage/rate limit nothing recovered automatically: offer the ways past
+                // it — fork to another agent now, or retry when the window resets.
+                record.limitHit = detectSessionLimit(turnError, { resetsAtHint: limitResetHint(record, Date.now()) });
+                if (record.limitHit) {
+                    const notice = sessionLimitNotice(getRuntime(record.runtimeId).displayName, record.limitHit);
+                    broadcast({ type: "session.notice", sessionId: record.id, level: "warn", ...notice });
+                }
                 // If the terminal error is an auth failure (expired key/token → 4xx),
                 // also raise the sign-in sheet for the failing provider.
                 maybeSignalAuthRequired(record, turnError);
@@ -11158,6 +11192,13 @@ app.post("/api/session/abort", (req, res, next) => {
         next(error);
     }
 });
+app.post("/api/session/limit-retry", (req, res) => {
+    const record = resolveSession(req.body?.sessionId);
+    if (!record)
+        return res.status(404).json({ error: "No active session" });
+    setSessionLimitRetry(record, req.body?.enabled === true);
+    res.json({ ok: true });
+});
 app.post("/api/session/turn-attention", (req, res, next) => {
     try {
         const record = resolveSession(req.body?.sessionId);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bivy/bivy",
-  "version": "0.17.3-staging.7",
+  "version": "0.17.3-staging.9",
   "type": "module",
   "license": "AGPL-3.0-only",
   "description": "Run coding agents on machines you own. Open-source, self-hostable agent workspace.",