@bivy/bivy 0.7.0-staging.99 → 0.8.0-staging.110

package/bin/bivy.mjs

@@ -3343,9 +3343,11 @@ async function cmdSetup(args = []) {
   console.log(`  ${agentReady ? c.green("✓") : c.yellow("!")} runtime ${agentReady ? `${setupAgent?.label || "Pi"} available` : "not installed — run 'bivy agents:install'"}`);
   console.log(`  ${modelReady ? (setupAgent?.needsBivyModel ? c.green("✓") : c.dim("○")) : c.yellow("!")} model ${modelReady ? (setupAgent?.needsBivyModel ? "credential configured" : "agent-managed — verified by the first task") : "not configured — run 'bivy login'"}`);
   console.log(`  ${c.dim("○")} repository chosen from the directory where you start Bivy`);
+  const ghReady = githubConnected(finalConfig);
+  console.log(`  ${ghReady ? c.green("✓") : c.dim("○")} GitHub ${ghReady ? "connected — your repos will list in the app" : c.dim("not connected — 'bivy github:connect' to list repos (optional)")}`);
   console.log(`  ${agentReady && modelReady ? c.green("✓") : c.yellow("!")} first task ${agentReady && modelReady ? "ready to try" : "blocked by the stage above"}`);
   console.log(`  ${fs.existsSync(relayConfigPath) ? c.green("✓") : c.yellow("!")} remote ${fs.existsSync(relayConfigPath) ? "configured" : "not configured — run 'bivy relay:setup'"}\n`);
-  printFirstRunSteps(modelReady);
+  printFirstRunSteps(modelReady, finalConfig);
   await finishSetupRemote(finalConfig, setupSession);
 }
 
@@ -3433,10 +3435,29 @@ async function openRemoteApp(config, { setupSession = null, open = true } = {})
   return { relay, remoteBase, accountUrl, pairedUrl, openUrl };
 }
 
-function printFirstRunSteps(modelReady = false) {
+// Whether GitHub is connected for repo listing/cloning. Bivy's own connect flow
+// (`bivy github:connect`, or the app's Connect button) writes BIVY_GITHUB_TOKEN
+// — usually a `secret://` vault reference — into cli.json's env; an explicit env
+// token counts too. A `gh auth login` session also works at runtime (the node
+// falls back to `gh auth token`), but that can't be known without shelling out,
+// so it's treated as "not connected here" — the hint is optional either way.
+function githubConnected(config = null) {
+  const token = String(
+    config?.env?.BIVY_GITHUB_TOKEN || process.env.BIVY_GITHUB_TOKEN || process.env.GITHUB_TOKEN || "",
+  ).trim();
+  return Boolean(token);
+}
+
+function printFirstRunSteps(modelReady = false, config = null) {
   console.log("  Run your first task:");
-  if (!modelReady) console.log(`    1. Model access:   ${c.cyan("bivy login")}  ${c.dim("(for Pi; other agents use their own login)")}`);
-  console.log(`    ${modelReady ? "1" : "2"}. Start chatting: ${c.cyan("bivy")}`);
+  let n = 0;
+  if (!modelReady) console.log(`    ${++n}. Model access:   ${c.cyan("bivy login")}  ${c.dim("(for Pi; other agents use their own login)")}`);
+  // GitHub is optional — "No repo" sessions work without it — so this only shows
+  // when nothing is connected yet, and never blocks the flow.
+  if (!githubConnected(config)) {
+    console.log(`    ${++n}. GitHub ${c.dim("(optional)")}: ${c.cyan("bivy github:connect")}  ${c.dim("— lets the app list your repos; required for private ones")}`);
+  }
+  console.log(`    ${++n}. Start chatting: ${c.cyan("bivy")}`);
   console.log(`       Starter task:  ${c.cyan('bivy exec "explain this repository and identify one low-risk improvement"')}\n`);
 }
 
@@ -3614,6 +3635,17 @@ async function cmdDoctor(args = []) {
   console.log(c.bold("\n  Bivy doctor\n"));
   console.log(`  ${mark(hasSupportedNode())} Node ${process.version}${hasSupportedNode() ? "" : c.dim("  (needs >= 22.19.0)")}`);
   console.log(`  ${mark(commandExists("git"), true)} git${commandExists("git") ? "" : c.dim("  (recommended for repo-backed sessions)")}`);
+  // GitHub is optional (a "No repo" session needs none), so this only ever warns.
+  // `gh` is NOT required — it's a token fallback; the primary path is Bivy's own
+  // 'bivy github:connect' (or the app's Connect button). We surface gh only as an
+  // available shortcut when it's installed but nothing is connected yet.
+  const ghConnected = githubConnected(config);
+  const ghHint = ghConnected
+    ? c.green("connected")
+    : commandExists("gh")
+      ? c.dim("not connected — 'bivy github:connect' (or 'gh auth login')")
+      : c.dim("not connected — 'bivy github:connect' to list/clone private repos");
+  console.log(`  ${mark(ghConnected, true)} GitHub ${ghHint}`);
   console.log(`  ${mark(reachable)} node ${reachable ? c.green("reachable") : c.dim("not reachable — 'bivy start'")} at ${url(config)}`);
   console.log(`  ${mark(/running/.test(serviceStatusLine()), true)} ${serviceStatusLine()}`);
   const defaultAgent = String(config.env?.BIVY_RUNTIME || runtimes?.current?.id || "pi");

package/dist/github-device-auth.js

@@ -67,6 +67,22 @@ export function interpretTokenResponse(data) {
     }
 }
 const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+/**
+ * A SINGLE access-token poll (no internal waiting) — for a caller that drives
+ * its own cadence. The web-driven connect flow uses this: the node holds the
+ * device code and the browser polls it on GitHub's interval, so the node never
+ * blocks a request thread in a poll loop. `pollForAccessToken` is the CLI's
+ * self-driving loop built on the same interpretation.
+ */
+export async function pollAccessTokenOnce(clientId, deviceCode) {
+    const res = await fetch(ACCESS_TOKEN_URL, {
+        method: "POST",
+        headers: { accept: "application/json", "content-type": "application/json" },
+        body: JSON.stringify({ client_id: clientId, device_code: deviceCode, grant_type: "urn:ietf:params:oauth:grant-type:device_code" }),
+    });
+    const data = (await res.json().catch(() => ({})));
+    return interpretTokenResponse(data);
+}
 /** Step 2: poll until the user authorizes (or the code expires). */
 export async function pollForAccessToken(clientId, device, signal) {
     let intervalMs = device.intervalSec * 1000;

package/dist/metadata.js

@@ -182,6 +182,20 @@ export class MetadataStore {
         this.data.sessions[id] = { ...prev, resumeAt: next, updatedAt: nowIso() };
         this.save();
     }
+    /** Set the durable consecutive auto-resume counter (the restart-safe backstop
+     *  for the in-memory reroute budget). Pass 0 to clear. No-op when the row is
+     *  missing or already in the requested state, so a normal turn (counter already
+     *  0) never churns the file. */
+    setResumeAttempts(id, attempts) {
+        const prev = this.data.sessions[id];
+        if (!prev)
+            return;
+        const next = attempts > 0 ? attempts : undefined;
+        if ((prev.resumeAttempts ?? undefined) === next)
+            return;
+        this.data.sessions[id] = { ...prev, resumeAttempts: next, updatedAt: nowIso() };
+        this.save();
+    }
     /** Sessions with a durable auto-resume time set — the resume sweep re-arms
      *  these after a restart. */
     sessionsWithResumeAt() {

package/dist/policy/session-reroute.js

@@ -92,8 +92,22 @@ export class SessionRerouteController {
         // long enough that it's clearly a limit rather than routine backoff.
         if (decision.resetsAt === undefined && decision.delayMs < MIN_RESUME_DELAY_MS)
             return null;
-        const resumeAt = decision.resetsAt ?? new Date(now + decision.delayMs).toISOString();
-        return { condition: decision.condition, summary: decision.summary, delayMs: Math.max(0, decision.delayMs), resumeAt };
+        // Resolve the due time (provider reset when known, else backoff) and floor it
+        // to at least MIN_RESUME_DELAY_MS in the FUTURE. A reset time can be in the
+        // past or ~now — a stale/elapsed reset, clock skew, or (most often) a window
+        // that already lapsed while the daemon was down — and using it verbatim yields
+        // a 0ms delay. The caller arms a timer at that delay, so a 0ms resume re-sends
+        // instantly, re-hits the still-standing limit, and re-schedules 0ms again: a
+        // tight loop that pins a CPU core and never settles. Flooring turns a
+        // not-yet-cleared limit into a slow retry the attempt budget can still park.
+        const rawDueMs = decision.resetsAt ? Date.parse(decision.resetsAt) : now + decision.delayMs;
+        const dueMs = Math.max(Number.isFinite(rawDueMs) ? rawDueMs : now, now + MIN_RESUME_DELAY_MS);
+        return {
+            condition: decision.condition,
+            summary: decision.summary,
+            delayMs: dueMs - now,
+            resumeAt: new Date(dueMs).toISOString(),
+        };
     }
     /** Advance the attempt budget once the caller has committed to a resume, so a
      *  limit that re-fires after the reset counts toward `maxAttempts` and can

package/dist/repo-workspace.js

@@ -100,6 +100,25 @@ export async function resolveGitHubToken(env = process.env) {
         return undefined;
     }
 }
+/**
+ * Whether the GitHub CLI (`gh`) is installed on this machine — used only to
+ * shade the "no GitHub token" message: when `gh` is present but `gh auth token`
+ * gave us nothing, the user is one `gh auth login` away, so the picker can say
+ * so. It never means `gh` is REQUIRED — `bivy github:connect` is the primary
+ * path and needs no CLI (see resolveGitHubToken). Mirrors the `command -v`
+ * probe in secrets.ts.
+ */
+export async function ghCliInstalled() {
+    const which = process.platform === "win32" ? "where" : "command";
+    const args = process.platform === "win32" ? ["gh"] : ["-v", "gh"];
+    try {
+        await exec(which, args, process.platform === "win32" ? {} : { shell: true });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
 /**
  * Refresh the remote-tracking refs so a session branches off the CURRENT state
  * of `origin`, not whatever the local checkout last saw. Best-effort: an offline

package/dist/runtime/index.js

@@ -116,14 +116,27 @@ function claudeCodeInfo() {
         },
     };
 }
+// Memoized CLI probes. `commandAvailable`/`resolveCommandPath`/`probeHelpText`
+// each shell out with a BLOCKING spawnSync, and the runtime catalog that calls
+// them (cliAgentInfo → prefersAcp/acpSupportedByBinary) is rebuilt often — on
+// every advertise and every runtimes.list send. Re-probing per build stalled the
+// event loop for seconds at a time (a synchronous spawn storm). A CLI's presence
+// is effectively constant for the daemon's run, so cache per command for the
+// process lifetime and clear on install (invalidateCliProbeCache).
+const COMMAND_AVAILABLE_CACHE = new Map();
 function commandAvailable(command) {
     if (!command.trim())
         return false;
+    const cached = COMMAND_AVAILABLE_CACHE.get(command);
+    if (cached !== undefined)
+        return cached;
     const result = spawnSync(process.platform === "win32" ? "where" : "command", process.platform === "win32" ? [command] : ["-v", command], {
         shell: process.platform !== "win32",
         stdio: "ignore",
     });
-    return result.status === 0;
+    const available = result.status === 0;
+    COMMAND_AVAILABLE_CACHE.set(command, available);
+    return available;
 }
 function genericCliInfo() {
     const options = processRuntimeFromEnv();
@@ -869,17 +882,23 @@ function cliThinkingConfig(id) {
  * Used to key the help-probe cache: caching by the bare NAME would keep serving a
  * stale answer after the binary behind that name changed (a CLI upgraded or
  * installed while the daemon is running, or a different PATH entry winning).
+ * Memoized per command (see COMMAND_AVAILABLE_CACHE) — it spawnSyncs, and is hit
+ * on every catalog build.
  */
+const COMMAND_PATH_CACHE = new Map();
 function resolveCommandPath(command) {
     if (!command.trim())
         return null;
+    const cached = COMMAND_PATH_CACHE.get(command);
+    if (cached !== undefined)
+        return cached;
     const res = spawnSync(process.platform === "win32" ? "where" : "command", process.platform === "win32" ? [command] : ["-v", command], {
         shell: process.platform !== "win32",
         encoding: "utf8",
     });
-    if (res.status !== 0)
-        return null;
-    return (res.stdout ?? "").split(/\r?\n/)[0]?.trim() || null;
+    const resolved = res.status !== 0 ? null : ((res.stdout ?? "").split(/\r?\n/)[0]?.trim() || null);
+    COMMAND_PATH_CACHE.set(command, resolved);
+    return resolved;
 }
 const HELP_PROBE_CACHE = new Map();
 function probeHelpText(command) {
@@ -898,6 +917,19 @@ function probeHelpText(command) {
     HELP_PROBE_CACHE.set(key, text);
     return text;
 }
+/**
+ * Drop every memoized CLI probe (availability, resolved path, --help text). These
+ * probes shell out with a blocking spawnSync and are cached for the process
+ * lifetime to keep the frequently-rebuilt runtime catalog off the event loop, so a
+ * CLI installed/updated mid-run wouldn't otherwise be noticed until a restart.
+ * Call this right after Bivy installs a runtime so the next catalog build re-probes
+ * and reflects the new binary immediately.
+ */
+export function invalidateCliProbeCache() {
+    COMMAND_AVAILABLE_CACHE.clear();
+    COMMAND_PATH_CACHE.clear();
+    HELP_PROBE_CACHE.clear();
+}
 // A resume template mixes launch flags (`-p`, `--force`) with the resume-specific
 // token(s) (`--resume`, `threads continue`, `-s`, `--restore`, …). Only the latter
 // evidence resume support, so we match on those — otherwise a shared launch flag

package/dist/secrets.js

@@ -183,8 +183,12 @@ export class SecretVault {
         if (fs.existsSync(this.keyFile))
             checks.push({ name: "local key file permissions", ok: modeIsPrivate(this.keyFile), detail: this.keyFile });
         checks.push({ name: "1Password CLI", ok: await commandExists("op"), detail: "required for op:// references" });
-        checks.push({ name: "GitHub CLI", ok: await commandExists("gh"), detail: "fallback for GitHub tokens when no Bivy secret is configured" });
-        return { ok: checks.every((c) => c.ok || c.name === "1Password CLI" || c.name === "GitHub CLI"), checks };
+        checks.push({ name: "GitHub CLI (optional)", ok: await commandExists("gh"), detail: "optional token shortcut; Bivy connects GitHub itself via `bivy github:connect`" });
+        // 1Password and the GitHub CLI are optional shortcuts — a missing one must
+        // not fail the vault's health (Bivy connects GitHub itself; op is only for
+        // op:// refs). Match on a stable prefix so renaming the label can't silently
+        // turn either back into a hard failure.
+        return { ok: checks.every((c) => c.ok || c.name.startsWith("1Password CLI") || c.name.startsWith("GitHub CLI")), checks };
     }
     key() {
         try {

package/dist/server.js

@@ -8,7 +8,7 @@ import { randomUUID, randomBytes, timingSafeEqual, createHash } from "node:crypt
 import { fileURLToPath } from "node:url";
 import express from "express";
 import { WebSocketServer, WebSocket } from "ws";
-import { listRuntimes, catalogRuntimes, cliInstallSpec, isCliAgentId } from "./runtime/index.js";
+import { listRuntimes, catalogRuntimes, cliInstallSpec, invalidateCliProbeCache, isCliAgentId } from "./runtime/index.js";
 import { createRunPolicy } from "./policy/run-policy.js";
 import { DEFAULT_BACKOFF } from "./policy/ruleset.js";
 import { SessionRerouteController } from "./policy/session-reroute.js";
@@ -60,7 +60,7 @@ import { checkDiskAdmission } from "./harness/disk-admission.js";
 import { sandboxTier, setConfiguredSandboxTier, normalizeSandboxTier } from "./harness/sandbox.js";
 import { setConfiguredAutoAttachToolImages } from "./harness/tool-image-attachments.js";
 import { injectMcpProxyForSession, injectBivyToolsForSession } from "./harness/mcp-inject.js";
-import { parseRepo, inferGitHubRepoFromWorkspace, isSharedCloneRoot, resolveGitHubToken, cloneOrUpdateRepo, resolveDefaultBaseRef, resolveBranchBaseRef, resolveAdoptBaseRef, fetchOrigin } from "./repo-workspace.js";
+import { parseRepo, inferGitHubRepoFromWorkspace, isSharedCloneRoot, resolveGitHubToken, ghCliInstalled, cloneOrUpdateRepo, resolveDefaultBaseRef, resolveBranchBaseRef, resolveAdoptBaseRef, fetchOrigin } from "./repo-workspace.js";
 import { configureGitAuth, writeGitCredentialEndpoint } from "./git-auth.js";
 import { GitHubTaskPoller, resolveGitHubTaskConfig, buildTaskPrompt, buildResumePrompt, buildInteractiveResumePrompt, DEFAULT_ISSUE_INSTRUCTIONS, parseBivyDirectives, commitAll, pushBranch, mergeBaseIntoBranch, completeMerge, abortMerge, findOpenPullRequestForBranch, findPullRequestsForBranch, findMergedPullRequestForBranch, issueBranchName, getPullRequest, commentIssue, listOpenLabelledIssues, selectActionableIssues, getIssue, getIssueCommentBody, addLabel, removeLabel, announcePickup, } from "./github-tasks.js";
 import { buildLinearTaskPrompt, getLinearIssue, linearBranchName } from "./linear-tasks.js";
@@ -84,6 +84,7 @@ import { ReplicationService } from "./session/replication-service.js";
 import { createSessionNewDedupe } from "./session/session-new-dedupe.js";
 import { evaluateForkPrereqs, blockingForkPrereqs, missingForkPrereqs } from "./session/fork-prereqs.js";
 import { SecretVault, resolveSecret } from "./secrets.js";
+import { deviceFlowClientId, requestDeviceCode, pollAccessTokenOnce, REPO_CONNECT_SCOPE } from "./github-device-auth.js";
 import { InstallationTokenCache, createAppJwt, resolveInstallationId } from "./github-app-auth.js";
 import { loadGitHubAppConfigs, orderAppsForOwner, listGitHubApps, removeGitHubApp, upsertGitHubApp, privateKeyIdFor, } from "./github-apps.js";
 import { buildAppManifest, convertManifest, renderManifestForm } from "./github-app-manifest.js";
@@ -2824,6 +2825,15 @@ const RELAY_COMMANDS = {
     async "repos.list"() {
         relay?.sendEvent({ type: "repos.list", ...(await listAccessibleRepos()) });
     },
+    // Web-driven "Connect GitHub" for the repo picker: start the node's device
+    // flow, then poll it on GitHub's interval. Both answer with the same
+    // `github.connect.status` event so the client has one shape to handle.
+    async "github.connect.start"() {
+        relay?.sendEvent({ type: "github.connect.status", ...(await startGithubConnect()) });
+    },
+    async "github.connect.poll"() {
+        relay?.sendEvent({ type: "github.connect.status", ...(await pollGithubConnect()) });
+    },
     // Branches for the repo the composer's repo pill just picked, so the branch
     // pill next to it can offer a specific remote branch to clone/base a new
     // session from instead of always the repo's default. See listRepoBranches.
@@ -3217,6 +3227,9 @@ const RELAY_COMMANDS = {
             const before = runtimeList().find((runtime) => runtime.id === spec.id);
             if (before?.status !== "available")
                 await runInstallCommand(spec);
+            // The just-installed binary changes what the CLI probes would report, so drop
+            // their (process-lifetime) cache and let the catalog below re-probe it.
+            invalidateCliProbeCache();
             const activeAgent = active?.runtimeId ?? defaultRuntimeId;
             const runtimes = runtimeList(activeAgent);
             relay?.sendEvent({ type: "runtime.install.done", id: spec.id, runtimes });
@@ -4345,6 +4358,12 @@ function startModelAuthWatcher() {
 let sessionAdvertiseTarget;
 let advertiseTimer;
 let advertiseResyncTimer;
+// Only one replace-all session advert may be in flight. If an older snapshot
+// (still containing a just-deleted/pruned session) completes after a newer one,
+// the control plane resurrects that row. Changes arriving during a request set
+// this flag and are sent immediately after it completes, in order.
+let advertiseRunning = false;
+let advertiseAgain = false;
 // How often the node re-affirms it's online to the control plane. Kept well
 // under the control plane's NODE_ONLINE_TTL_MS (90s) so a missed beat or two
 // doesn't flap a healthy node's status.
@@ -4575,11 +4594,17 @@ async function advertiseSessions() {
             : [];
         return {
             sessionId: s.id,
-            status: pendingApproval || failureAttention.length ? "needs_action" : (record ? (sessionBusy(record) ? "working" : "idle") : "saved"),
-            needsAction: pendingApproval || failureAttention.length > 0,
+            // Failures (including exhausted credits/rate limits) are outcomes to
+            // review, not blocking questions that keep saying "Needs your response".
+            // Only a still-pending approval/question owns that status.
+            status: pendingApproval ? "needs_action" : (record ? (sessionBusy(record) ? "working" : "idle") : "saved"),
+            needsAction: pendingApproval,
             source: record?.source || meta?.source,
             titleEnc: name ? relay.sealString(name) : undefined,
             branch: record?.worktree?.branch || meta?.branch,
+            // This is activity time, not advert receive time. A daemon restart/full
+            // resync must not make every historical row appear freshly updated.
+            updatedAt: isoFrom(record?.lastTouchedAt ?? meta?.lastActivityAt ?? meta?.updatedAt ?? s.modified),
             agentServiceAddress,
             githubIssueUrl: record?.githubIssueUrl,
             prUrl: record?.prUrl,
@@ -4597,16 +4622,39 @@ async function advertiseSessions() {
         // best effort; the periodic resync and the next change will retry
     }
 }
-/** Debounced advertise — many session events collapse into one POST. */
+/** Debounced, serialized advertise — many session events collapse into one
+ * POST, and replace-all snapshots can never complete out of order. */
 function scheduleAdvertise() {
-    if (!sessionAdvertiseTarget || advertiseTimer)
+    if (!sessionAdvertiseTarget)
+        return;
+    if (advertiseRunning) {
+        advertiseAgain = true;
+        return;
+    }
+    if (advertiseTimer)
         return;
     advertiseTimer = setTimeout(() => {
         advertiseTimer = undefined;
-        void advertiseSessions();
+        void drainSessionAdverts();
     }, 1000);
     advertiseTimer.unref?.();
 }
+async function drainSessionAdverts() {
+    if (advertiseRunning) {
+        advertiseAgain = true;
+        return;
+    }
+    advertiseRunning = true;
+    try {
+        do {
+            advertiseAgain = false;
+            await advertiseSessions();
+        } while (advertiseAgain);
+    }
+    finally {
+        advertiseRunning = false;
+    }
+}
 let githubPoller;
 /**
  * Serialize all work for one issue (keyed by its `issue:owner/repo#N` source).
@@ -6886,6 +6934,14 @@ const SESSION_RESUME_SWEEP_MS = 60_000;
 /** Slack around "due": a capped timer may fire a touch early — drive only when
  *  within this of the target, else re-arm. */
 const SESSION_RESUME_TICK_MS = 15_000;
+/** Hard ceiling on consecutive auto-resumes for one session before we give up and
+ *  surface the limit. The reroute controller already caps per turn, but its budget
+ *  is in-memory: a session re-resolved after its child exits on the limit (or a
+ *  daemon restart) gets a fresh controller, so without a durable count a limit that
+ *  never actually clears would re-send every MIN_RESUME_DELAY_MS indefinitely.
+ *  Generous enough to ride out a mis-parsed multi-day window (each wait is ≥1 min,
+ *  usually far longer), low enough to bound a genuinely stuck limit. */
+const MAX_DURABLE_RESUME_ATTEMPTS = 10;
 const sessionResumeTimers = new Map();
 // Fire due auto-resumes (a usage/rate limit that has since reset) and re-arm the
 // tail of long waits whose in-process timer was capped or lost to a restart.
@@ -7192,10 +7248,20 @@ function armSessionResumeTimer(id, dueMs) {
     timer.unref?.();
     sessionResumeTimers.set(id, timer);
 }
-/** Persist + arm an auto-resume decided by the session policy. Synchronous so
- *  the caller can atomically suppress the turn's error toast. */
+/** Persist + arm an auto-resume decided by the session policy. Synchronous so the
+ *  caller can atomically suppress the turn's error toast. Returns false when the
+ *  session has already exhausted its durable auto-resume budget (a limit that never
+ *  clears) — the caller then lets the error surface instead of looping. */
 function scheduleSessionResume(record, plan) {
+    const attempts = metadata.getSession(record.id)?.resumeAttempts ?? 0;
+    if (attempts >= MAX_DURABLE_RESUME_ATTEMPTS) {
+        console.warn(`[resume] session ${record.id} hit the durable auto-resume cap (${MAX_DURABLE_RESUME_ATTEMPTS}) without the limit clearing — giving up`);
+        clearSessionResume(record.id);
+        metadata.setResumeAttempts(record.id, 0);
+        return false;
+    }
     metadata.setResumeAt(record.id, plan.resumeAt);
+    metadata.setResumeAttempts(record.id, attempts + 1);
     const when = Date.parse(plan.resumeAt);
     const cond = plan.condition.replace(/_/g, " ");
     broadcast({
@@ -7205,6 +7271,7 @@ function scheduleSessionResume(record, plan) {
         message: `Hit a ${cond} limit — I'll resume this automatically when it resets (${plan.resumeAt}).`,
     });
     armSessionResumeTimer(record.id, Number.isFinite(when) ? when : Date.now());
+    return true;
 }
 /** Fire a due auto-resume: re-open the session if needed and re-send the turn's
  *  last prompt. Clears the durable marker BEFORE driving so a crash mid-resume
@@ -7484,6 +7551,10 @@ function attachSessionListeners(record) {
                     resetsAtHint: limitResetHint(record, Date.now()),
                 }) ?? null
                 : null;
+            // Did this turn end by scheduling another auto-resume? If not, the session
+            // made forward progress (a user turn, a resume that cleared the limit, a
+            // reroute, or a surfaced error), so its durable resume streak resets below.
+            let scheduledResume = false;
             if (reroutePlan) {
                 void record.reroute.applyReroute(reroutePlan, {
                     getCurrentModelName: () => record.session.getCurrentModel()?.name,
@@ -7493,12 +7564,14 @@ function attachSessionListeners(record) {
                     },
                 });
             }
-            else if (resumePlan) {
+            else if (resumePlan && scheduleSessionResume(record, resumePlan)) {
                 // Charge the attempt budget so a limit that re-fires after the reset can
                 // eventually exhaust (→ surface) instead of looping, then park the turn
-                // as a scheduled resume rather than a dead error.
+                // as a scheduled resume rather than a dead error. scheduleSessionResume
+                // returns false once the durable cap is hit, so this falls through to
+                // surface the limit instead of resuming forever.
                 record.reroute.noteResumeApplied();
-                scheduleSessionResume(record, resumePlan);
+                scheduledResume = true;
             }
             else if (messageError) {
                 // Only the server-owned (pi-ai) path surfaces here; a Claude Code error
@@ -7527,6 +7600,11 @@ function attachSessionListeners(record) {
                     body: `${sessionNotifyLabel(record)} finished — tap to review the result.`,
                 });
             }
+            // Any turn that didn't schedule another resume broke the limit streak —
+            // clear the durable counter so a future limit starts with a full budget
+            // (no-op when it's already 0, so a normal turn never touches the file).
+            if (!scheduledResume)
+                metadata.setResumeAttempts(record.id, 0);
             // First real commit on a repo-backed worktree → publish the branch to the
             // remote (sets upstream), so the work is visible on GitHub. No-op until
             // there's a commit, and only pushes once. Then adopt a PR the agent opened
@@ -10066,7 +10144,7 @@ async function listAccessibleRepos() {
     try {
         const token = await resolveGitHubToken();
         if (!token)
-            return { authed: false, repos: [] };
+            return { authed: false, repos: [], reason: (await ghCliInstalled()) ? "gh-unauthed" : "no-token" };
         const ghRes = await fetch("https://api.github.com/user/repos?sort=updated&per_page=100&affiliation=owner,collaborator,organization_member", {
             headers: { authorization: `Bearer ${token}`, accept: "application/vnd.github+json", "user-agent": "bivy" },
         });
@@ -10091,6 +10169,83 @@ async function listAccessibleRepos() {
         return { authed: false, repos: [], error: error instanceof Error ? error.message : String(error) };
     }
 }
+let pendingGithubConnect = null;
+async function startGithubConnect() {
+    const clientId = deviceFlowClientId();
+    if (!clientId)
+        return { status: "unconfigured" };
+    try {
+        const device = await requestDeviceCode(clientId, REPO_CONNECT_SCOPE);
+        pendingGithubConnect = { clientId, device, expiresAt: Date.now() + device.expiresInSec * 1000 };
+        return {
+            status: "waiting",
+            userCode: device.userCode,
+            verificationUri: device.verificationUri,
+            intervalMs: device.intervalSec * 1000,
+            expiresInMs: device.expiresInSec * 1000,
+        };
+    }
+    catch (error) {
+        return { status: "error", error: error instanceof Error ? error.message : String(error) };
+    }
+}
+async function pollGithubConnect() {
+    const pending = pendingGithubConnect;
+    if (!pending)
+        return { status: "idle" };
+    if (Date.now() > pending.expiresAt) {
+        pendingGithubConnect = null;
+        return { status: "expired" };
+    }
+    let poll;
+    try {
+        poll = await pollAccessTokenOnce(pending.clientId, pending.device.deviceCode);
+    }
+    catch (error) {
+        // A transient network blip mid-flow — keep the code alive and let the client
+        // poll again rather than discarding a device code the user may have authorized.
+        return { status: "error", error: error instanceof Error ? error.message : String(error) };
+    }
+    switch (poll.status) {
+        case "ok":
+            pendingGithubConnect = null;
+            persistConnectedGithubToken(poll.token);
+            return { status: "connected" };
+        case "slow_down":
+            // GitHub says we're polling too fast — widen the interval it hands the
+            // browser so the next poll backs off (and doesn't burn the device code).
+            pending.device.intervalSec = poll.intervalSec ?? pending.device.intervalSec + 5;
+        // falls through — same "keep waiting" answer, just a larger interval.
+        case "pending":
+            return {
+                status: "waiting",
+                userCode: pending.device.userCode,
+                verificationUri: pending.device.verificationUri,
+                intervalMs: pending.device.intervalSec * 1000,
+                expiresInMs: Math.max(0, pending.expiresAt - Date.now()),
+            };
+        case "denied":
+            pendingGithubConnect = null;
+            return { status: "denied" };
+        case "expired":
+            pendingGithubConnect = null;
+            return { status: "expired" };
+        default:
+            pendingGithubConnect = null;
+            return { status: "error", error: poll.error };
+    }
+}
+// Store the repo-scoped token exactly like `bivy github:connect`: the raw token
+// in the node's secret vault, and only a `secret://` reference in cli.json. But
+// ALSO update the LIVE process env so resolveGitHubToken() picks it up without a
+// restart (the Tier-1 caveat), and drop the repo-list cache so the very next
+// list is authed.
+function persistConnectedGithubToken(token) {
+    new SecretVault(appDir).setLocal("github.repo-token", token, "GitHub repo/work-queue token");
+    saveCliEnv({ BIVY_GITHUB_TOKEN: "secret://github.repo-token" });
+    process.env.BIVY_GITHUB_TOKEN = "secret://github.repo-token";
+    invalidateGithubListingCaches();
+}
 // Fetch a repo's remote branch names with a given token (or none, for a public
 // repo). One GitHub call; returns null on a non-OK response so the caller can
 // decide whether to retry with a different token.
@@ -10514,6 +10669,13 @@ app.get("/github/app/manifest/callback", async (req, res, next) => {
 app.get("/api/repos", async (_req, res) => {
     res.json(await listAccessibleRepos());
 });
+// Direct-transport (local PWA) equivalents of the github.connect.* commands.
+app.post("/api/github/connect/start", async (_req, res) => {
+    res.json(await startGithubConnect());
+});
+app.get("/api/github/connect/poll", async (_req, res) => {
+    res.json(await pollGithubConnect());
+});
 app.get("/api/repos/branches", async (req, res) => {
     res.json(await listRepoBranches(String(req.query.repo || "").trim()));
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bivy/bivy",
-  "version": "0.7.0-staging.99",
+  "version": "0.8.0-staging.110",
   "type": "module",
   "license": "FSL-1.1-ALv2",
   "description": "Run coding agents on machines you own. Source-available, self-hostable agent workspace.",