@bivy/bivy 0.15.0-staging.50 → 0.15.0-staging.52

package/dist/control-plane-tasks.js

@@ -386,7 +386,17 @@ export class ControlPlaneTaskPoller {
                         ],
                     });
                     if (decision.action === "reroute") {
-                        current = { ...current, runtimeId: decision.routing.runtimeId, model: decision.routing.model };
+                        // A candidate changes only the routing dimensions it names. Preserve
+                        // the existing runtime/model for partial fallback routes (for example
+                        // a model-only fallback must not silently reset the selected agent).
+                        current = {
+                            ...current,
+                            ...(decision.routing.runtimeId !== undefined ? { runtimeId: decision.routing.runtimeId } : {}),
+                            ...(decision.routing.model !== undefined ? { model: decision.routing.model } : {}),
+                            // Account routing is not yet represented by WorkItem. Do not claim
+                            // that an account fallback was applied until the queue wire shape
+                            // and credential resolver support it end-to-end.
+                        };
                         rerouteCount = decision.rerouteCount;
                         await report({ routingReason: `fallback: ${decision.ref}` });
                     }

package/dist/policy/ruleset.js

@@ -94,8 +94,25 @@ export const DEFAULT_RULESET = {
  * human-readable errors — never throws.
  */
 export function validateRuleset(value) {
-    if (Check(RulesetSchema, value))
-        return { ok: true, ruleset: value, errors: [] };
+    if (Check(RulesetSchema, value)) {
+        const ruleset = value;
+        const errors = [];
+        for (let ruleIndex = 0; ruleIndex < ruleset.rules.length; ruleIndex += 1) {
+            const rule = ruleset.rules[ruleIndex];
+            if (rule.action !== "reroute" || !rule.chain)
+                continue;
+            for (let candidateIndex = 0; candidateIndex < rule.chain.length; candidateIndex += 1) {
+                const candidate = rule.chain[candidateIndex];
+                const hasRoute = [candidate.runtimeId, candidate.model, candidate.account]
+                    .some((field) => typeof field === "string" && field.trim().length > 0);
+                if (!hasRoute)
+                    errors.push(`/rules/${ruleIndex}/chain/${candidateIndex}: fallback candidate must specify runtimeId, model, or account`);
+            }
+        }
+        if (errors.length)
+            return { ok: false, errors };
+        return { ok: true, ruleset, errors: [] };
+    }
     const errors = [...Errors(RulesetSchema, value)]
         .slice(0, 20)
         .map((e) => `${e.path || "/"}: ${e.message}`);

package/dist/server.js

@@ -4592,11 +4592,58 @@ async function reconcileInterruptedSessions() {
         }
     }
 }
+/** Run the legacy direct GitHub queue through the same failure policy as the
+ * hosted queue. There is no control-plane run/evidence endpoint on this path,
+ * so the policy is applied locally and terminal failures retain the poller's
+ * existing logging behavior. */
+async function runDirectGitHubIssueWithPolicy(cfg, issue) {
+    let ruleset;
+    try {
+        // Repository policy has precedence, matching the hosted queue. An invalid
+        // project policy must not disable the direct poller; fall back to the
+        // node-global policy and leave the validation error visible in the log.
+        ruleset = loadProjectPolicy(cfg.repoDir)?.ruleset;
+    }
+    catch (error) {
+        console.warn(`[policy] ${error instanceof Error ? error.message : String(error)}`);
+    }
+    const policy = createRunPolicy({
+        context: "queue",
+        ruleset: ruleset ?? activeRulesetFor(rulesetsDir, "queue"),
+    });
+    let attempt = 1;
+    let rerouteCount = 0;
+    let routing = {};
+    for (;;) {
+        try {
+            await runIssueTask(cfg, issue, { ...routing });
+            return;
+        }
+        catch (error) {
+            const decision = policy.decide({ routing, error, attempt, rerouteCount });
+            if (decision.action !== "retry" && decision.action !== "reroute")
+                throw error;
+            attempt += 1;
+            if (decision.action === "reroute") {
+                routing = {
+                    ...(routing.runtimeId !== undefined ? { runtimeId: routing.runtimeId } : {}),
+                    ...(routing.model !== undefined ? { model: routing.model } : {}),
+                    ...(decision.routing.runtimeId !== undefined ? { runtimeId: decision.routing.runtimeId } : {}),
+                    ...(decision.routing.model !== undefined ? { model: decision.routing.model } : {}),
+                };
+                rerouteCount = decision.rerouteCount;
+            }
+            console.warn(`[github-tasks] issue #${issue.number} ${decision.action} (${decision.condition}): ${decision.summary}`);
+            if (decision.delayMs > 0)
+                await new Promise((resolve) => setTimeout(resolve, decision.delayMs));
+        }
+    }
+}
 async function startGitHubTasksIfConfigured() {
     const cfg = await resolveGitHubTaskConfig();
     if (!cfg)
         return;
-    githubPoller = new GitHubTaskPoller(cfg, (issue) => runIssueTask(cfg, issue), nodeGithubMaxConcurrent);
+    githubPoller = new GitHubTaskPoller(cfg, (issue) => runDirectGitHubIssueWithPolicy(cfg, issue), nodeGithubMaxConcurrent);
     githubPoller.start();
 }
 let controlPlanePoller;

package/package.json

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