@bivy/bivy 0.7.0 → 0.8.0

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";
@@ -501,11 +502,11 @@ const terminals = new TerminalManager();
 // and fixed for that session's life; switching agents in the UI starts a new one.
 let defaultRuntimeId = (process.env.BIVY_RUNTIME ?? "pi").toLowerCase();
 const runtimeHost = new RuntimeHost({ credsDir, piDir, sessionsDir, attachToChat: attachToChatForSession });
-// In-session model reroute (docs/rulesets.md). Opt-in: set
-// BIVY_SESSION_MODEL_FALLBACK to a comma-separated model list and a session that
-// hits an exhausted-credits / rate-limit turn error swaps down the list (via the
-// runtime's live setModel) and retries, instead of surfacing the error. Absent =
-// inert, session behavior unchanged.
+// A built-in in-session model-fallback ruleset from BIVY_SESSION_MODEL_FALLBACK
+// (docs/rulesets.md). Opt-in: set it to a comma-separated model list and a
+// session that hits an exhausted-credits / rate-limit turn error swaps down the
+// list (via the runtime's live setModel) and retries. Used only when the user
+// hasn't authored their own session-scoped ruleset in the UI.
 function sessionModelFallbackRuleset() {
     const models = (process.env.BIVY_SESSION_MODEL_FALLBACK ?? "")
         .split(",")
@@ -529,9 +530,21 @@ function sessionModelFallbackRuleset() {
         ],
     };
 }
-const sessionRuleset = sessionModelFallbackRuleset();
-const sessionRunPolicy = sessionRuleset ? createRunPolicy({ ruleset: sessionRuleset, context: "session" }) : undefined;
-if (sessionRunPolicy) {
+/** The ruleset in-session recovery runs under right now: the user's active
+ *  ruleset if it applies to sessions, else the env model-fallback ruleset, else
+ *  undefined (→ built-in DEFAULT_RULESET). Read lazily on each turn error so UI
+ *  edits take effect without a restart, mirroring activeQueueRuleset. */
+function activeSessionRuleset() {
+    return activeRulesetFor(rulesetsDir, "session") ?? sessionModelFallbackRuleset();
+}
+// The in-session recovery effector's policy. Always available: an interactive
+// session can wait out a provider usage/rate limit and resume when it resets
+// (planResume), or swap models down a fallback chain (planReroute). Thin wrapper
+// so a freshly-saved active ruleset is picked up on the next turn error.
+const sessionRunPolicy = {
+    decide: (ctx) => createRunPolicy({ context: "session", ruleset: activeSessionRuleset() }).decide(ctx),
+};
+if (process.env.BIVY_SESSION_MODEL_FALLBACK) {
     console.log(`[policy] in-session model reroute enabled: ${process.env.BIVY_SESSION_MODEL_FALLBACK}`);
 }
 let lastUpdateCheckAt = 0;
@@ -2812,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.
@@ -3205,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 });
@@ -3542,6 +3567,9 @@ const RELAY_COMMANDS = {
             record.lastPrompt = agentPrompt;
             record.lastPromptOptions = promptOptionsFor(record, msg.streamingBehavior, images);
             record.reroute?.beginTurn();
+            // 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);
             await promptWithWatchdog(record, agentPrompt, record.lastPromptOptions);
         }).catch((error) => {
             // Mirror the HTTP path (see the /prompt route): a rejected turn after
@@ -4330,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.
@@ -4560,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,
@@ -4582,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).
@@ -6862,6 +6925,28 @@ const idleCloseTimer = setInterval(() => { closeIdleSessions(); pruneGhostSessio
 idleCloseTimer.unref?.();
 const worktreeCleanupTimer = setInterval(() => void sweepDiskGuardrails(), worktreeCleanupSweepMs);
 worktreeCleanupTimer.unref?.();
+// In-session auto-resume tunables (see the resume helpers below). setTimeout
+// can't be trusted past ~24.8 days and we don't want one timer owning a
+// multi-hour wait a restart would drop, so each timer is capped and the periodic
+// sweep re-arms the remainder from the persisted resumeAt.
+const SESSION_RESUME_MAX_TIMER_MS = 30 * 60_000;
+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.
+const sessionResumeTimer = setInterval(() => sessionResumeSweep(), SESSION_RESUME_SWEEP_MS);
+sessionResumeTimer.unref?.();
 // --- server-side ephemeral teardown ----------------------------------------
 // On a disposable machine (bootstrap set BIVY_EPHEMERAL=1) the daemon ends the
 // machine ITSELF once it goes idle, so teardown no longer needs the launching
@@ -7111,6 +7196,136 @@ async function refreshSessionUsage(record) {
         // Usage reporting must never affect the session it's reporting on.
     }
 }
+// ── In-session auto-resume after a usage/rate limit ─────────────────────────
+// When a turn ends because a provider window is exhausted ("you've hit your
+// weekly limit · resets 12am (UTC)") and the session's ruleset says retry, we
+// wait out the window and re-send the same prompt when it resets — instead of
+// leaving a dead error bubble. Durable: the due time is persisted (metadata
+// resumeAt) so a daemon restart re-arms it (sessionResumeSweep); an in-process
+// timer fires it promptly while the daemon is up. (Tunables + timer map are
+// declared up by the timer cluster so the sweep interval can reference them.)
+/** The authoritative reset time for the limit a session just hit: the soonest
+ *  future reset among its most-utilized usage windows (the binding one), from
+ *  the last snapshot the runtime reported. Essential for a multi-day "weekly"
+ *  window, whose error text states only a time-of-day. Undefined when unknown. */
+function limitResetHint(record, nowMs) {
+    const windows = record.usage?.plan?.windows ?? [];
+    let best;
+    for (const w of windows) {
+        if (!w.resetsAt)
+            continue;
+        const at = Date.parse(w.resetsAt);
+        if (!Number.isFinite(at) || at <= nowMs)
+            continue;
+        const util = w.utilizationPct ?? 0;
+        // Prefer the most-utilized window (the one being hit); tie-break on soonest reset.
+        if (!best || util > best.util || (util === best.util && at < best.at))
+            best = { at, util };
+    }
+    return best ? new Date(best.at).toISOString() : undefined;
+}
+/** Cancel a pending in-process resume timer (leaves the durable marker alone). */
+function cancelSessionResumeTimer(id) {
+    const timer = sessionResumeTimers.get(id);
+    if (timer) {
+        clearTimeout(timer);
+        sessionResumeTimers.delete(id);
+    }
+}
+/** Clear both the durable resume marker and any armed timer — the session moved
+ *  on (a new user turn, or the resume itself started). */
+function clearSessionResume(id) {
+    cancelSessionResumeTimer(id);
+    metadata.setResumeAt(id, null);
+}
+function armSessionResumeTimer(id, dueMs) {
+    cancelSessionResumeTimer(id);
+    const delay = Math.min(Math.max(0, dueMs - Date.now()), SESSION_RESUME_MAX_TIMER_MS);
+    const timer = setTimeout(() => {
+        sessionResumeTimers.delete(id);
+        void driveSessionResume(id);
+    }, delay);
+    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. 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({
+        type: "session.notice",
+        sessionId: record.id,
+        level: "info",
+        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
+ *  can't loop. Best-effort — never throws into a timer/sweep. */
+async function driveSessionResume(id) {
+    const meta = metadata.getSession(id);
+    if (!meta?.resumeAt)
+        return; // cancelled or already resumed
+    const due = Date.parse(meta.resumeAt);
+    if (Number.isFinite(due) && due - Date.now() > SESSION_RESUME_TICK_MS) {
+        // A capped timer fired before the real due time — re-arm for the remainder.
+        armSessionResumeTimer(id, due);
+        return;
+    }
+    clearSessionResume(id);
+    try {
+        const live = openSessions.get(id);
+        if (live?.isWorking)
+            return; // a user turn is already running — don't pile on
+        const record = live ?? (await resolveOrResumeSession(id, meta.path));
+        if (!record)
+            return; // transcript gone / unresolvable
+        if (record.isWorking)
+            return;
+        // In-memory lastPrompt is the exact user turn to retry; after a restart it's
+        // gone, so fall back to the generic interrupted-turn continuation nudge.
+        const prompt = record.lastPrompt ?? buildInteractiveResumePrompt();
+        console.log(`[resume] auto-resuming session ${id} — provider limit has reset`);
+        broadcast({ type: "session.notice", sessionId: id, level: "info", message: "The limit has reset — resuming now." });
+        await promptWithWatchdog(record, prompt, record.lastPromptOptions);
+    }
+    catch (error) {
+        console.warn(`[resume] auto-resume after a provider limit failed for ${id}`, error);
+    }
+}
+/** 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. */
+function sessionResumeSweep() {
+    const now = Date.now();
+    for (const meta of metadata.sessionsWithResumeAt()) {
+        const due = Date.parse(meta.resumeAt);
+        if (!Number.isFinite(due)) {
+            metadata.setResumeAt(meta.id, null);
+            continue;
+        }
+        if (sessionResumeTimers.has(meta.id))
+            continue; // already armed this run
+        if (due <= now + SESSION_RESUME_TICK_MS)
+            void driveSessionResume(meta.id);
+        else
+            armSessionResumeTimer(meta.id, due);
+    }
+}
 /**
  * Turn a raw provider/runtime error string into something a human can read.
  * Model APIs commonly return `<status> {json}` (e.g. `400 {"error":{"message":
@@ -7184,9 +7399,12 @@ function maybeSignalAuthRequired(record, errorText) {
 }
 function attachSessionListeners(record) {
     record.unsubscribe?.();
-    // In-session model reroute controller (inert unless BIVY_SESSION_MODEL_FALLBACK
-    // is set). One per session; its per-turn budget resets on each user prompt.
-    if (sessionRunPolicy && !record.reroute) {
+    // In-session recovery controller — waits out a usage/rate limit and resumes
+    // (planResume), or swaps models down a fallback chain (planReroute). One per
+    // session; its per-turn budget resets on each user prompt. The policy reads
+    // the active session ruleset lazily, so it's inert until one authorizes a
+    // retry/reroute for the failing condition.
+    if (!record.reroute) {
         record.reroute = new SessionRerouteController({
             policy: sessionRunPolicy,
             onNotice: (n) => broadcast({ type: "session.notice", sessionId: record.id, level: n.level, message: n.message }),
@@ -7306,7 +7524,18 @@ function attachSessionListeners(record) {
             // credential or a 4xx from the API) otherwise vanished: working cleared,
             // no reply, no signal. Surface it as a session-scoped error so the client
             // can show it *inline in that chat*, and notify instead of "done".
-            const turnError = terminalTurnError(event);
+            // A terminal turn error reaches us two ways. pi-ai puts it on the last
+            // assistant message (stopReason:"error" → terminalTurnError), and the
+            // server owns surfacing it. Claude Code instead throws inside the SDK
+            // query: it emits its OWN session.error to the client AND carries the raw
+            // text on agent_end.error (e.g. "you've hit your weekly limit · resets 12am
+            // (UTC)"). We read that too — but only to DRIVE recovery, since the runtime
+            // already surfaced it; re-broadcasting would double the error bubble.
+            const messageError = terminalTurnError(event);
+            const agentEndError = typeof event.error === "string"
+                ? humanizeAgentError(event.error)
+                : undefined;
+            const turnError = messageError ?? (agentEndError?.trim() ? agentEndError : undefined);
             // Before surfacing a turn error, see if the session's run policy can recover
             // it in place by swapping to a fallback model and retrying the same prompt.
             // planReroute is synchronous, so we can atomically suppress the error toast
@@ -7314,6 +7543,18 @@ function attachSessionListeners(record) {
             const reroutePlan = turnError && record.lastPrompt !== undefined
                 ? record.reroute?.planReroute(turnError, record.session.getCurrentModel()?.name) ?? null
                 : null;
+            // If a reroute doesn't apply, a usage/rate limit that gave a reset time can
+            // instead be waited out and resumed when the window clears (planResume is
+            // synchronous too, so this stays atomic with suppressing the error toast).
+            const resumePlan = !reroutePlan && turnError && record.lastPrompt !== undefined
+                ? record.reroute?.planResume(turnError, record.session.getCurrentModel()?.name, {
+                    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,
@@ -7323,14 +7564,25 @@ function attachSessionListeners(record) {
                     },
                 });
             }
-            else if (turnError) {
+            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. scheduleSessionResume
+                // returns false once the durable cap is hit, so this falls through to
+                // surface the limit instead of resuming forever.
+                record.reroute.noteResumeApplied();
+                scheduledResume = true;
+            }
+            else if (messageError) {
+                // Only the server-owned (pi-ai) path surfaces here; a Claude Code error
+                // the runtime already broadcast falls through to avoid a duplicate bubble.
                 record.lastFailureAt = Date.now();
                 metadata.touchSession(record.id, "failed");
                 scheduleAdvertise();
-                broadcast({ type: "session.error", sessionId: record.id, error: turnError });
+                broadcast({ type: "session.error", sessionId: record.id, error: messageError });
                 // 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);
+                maybeSignalAuthRequired(record, messageError);
                 void sendNotificationHint({
                     kind: "session_error",
                     sessionId: record.id,
@@ -7348,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
@@ -9887,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" },
         });
@@ -9912,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.
@@ -10335,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()));
 });
@@ -10655,6 +10996,14 @@ const server = app.listen(port, host, async () => {
     // Recover interactive sessions a restart interrupted mid-turn (auto-continue, or
     // flag for a one-tap manual Resume) per the node's sessionResumeMode setting.
     void reconcileInterruptedSessions().catch((error) => console.warn("[resume] interrupted-session reconciliation failed", error));
+    // Re-arm (or fire) durable auto-resume markers a limit-hit turn left behind,
+    // so a session waiting out a usage/rate window still resumes after a restart.
+    try {
+        sessionResumeSweep();
+    }
+    catch (error) {
+        console.warn("[resume] auto-resume sweep failed at boot", error);
+    }
     // Universal Agent Harness — network effect boundary (opt-in via
     // BIVY_EGRESS_PROXY). Governs/logs outbound traffic of CLI agents, which
     // inherit the proxy env from process.ts.

package/package.json

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