@whittlelabs/sifter 0.41.2 → 0.42.0

package/bin.js

@@ -52579,7 +52579,7 @@ var require_ajvProvider_ZaoO9afR = __commonJS({
       };
       exports3.default = formatLimitPlugin;
     }));
-    var require_dist8 = /* @__PURE__ */ require_chunk.__commonJSMin(((exports3, module3) => {
+    var require_dist9 = /* @__PURE__ */ require_chunk.__commonJSMin(((exports3, module3) => {
       Object.defineProperty(exports3, "__esModule", { value: true });
       const formats_1 = require_formats();
       const limit_1 = require_limit();
@@ -52614,7 +52614,7 @@ var require_ajvProvider_ZaoO9afR = __commonJS({
     var import_ajv = require_ajv();
     var import__2019 = require__2019();
     var import__2020 = require__2020();
-    var import_dist = /* @__PURE__ */ require_chunk.__toESM(require_dist8(), 1);
+    var import_dist = /* @__PURE__ */ require_chunk.__toESM(require_dist9(), 1);
     var addFormats = import_dist.default;
     function createDefaultAjvInstance(engineClass) {
       const ajv = new engineClass({
@@ -68366,6 +68366,28 @@ var require_client2 = __commonJS({
           shift: shift ?? null
         };
       }
+      /**
+       * Open the subscriber's hint stream (`GET /api/my/jobs/stream`, whittlelabs
+       * ADR 0137) and hand back the raw response for @whittlelabs/realtime's
+       * reader. Authenticated as every call, a 401 retried once with a refreshed
+       * token. Naming the shift makes the open stream its check-in.
+       */
+      async openHintStream(options = {}) {
+        const qs = options.shift ? `?shift=${encodeURIComponent(options.shift)}` : "";
+        const url = `${this.baseUrl}/api/my/jobs/stream${qs}`;
+        const headers = async (forceRefresh) => ({
+          ...await this.buildHeaders(forceRefresh),
+          Accept: "text/event-stream",
+          ...options.lastEventId ? { "Last-Event-ID": options.lastEventId } : {}
+        });
+        let response = await fetch(url, { headers: await headers(false), signal: options.signal });
+        if (response.status === 401 && this.getAccessToken) {
+          await response.body?.cancel().catch(() => void 0);
+          response = await fetch(url, { headers: await headers(true), signal: options.signal });
+        }
+        this.onResponse?.(response);
+        return response;
+      }
       // ── HTTP plumbing ────────────────────────────────────────────────
       /**
        * Every call's one reader. `readJsonResponse` refuses to parse a reply that
@@ -68391,12 +68413,181 @@ var require_client2 = __commonJS({
   }
 });
 
+// ../../packages/realtime-client/dist/reader.js
+var require_reader = __commonJS({
+  "../../packages/realtime-client/dist/reader.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.StreamSilentError = exports2.RESYNC = void 0;
+    exports2.readEventStream = readEventStream;
+    exports2.connectStream = connectStream;
+    exports2.RESYNC = "resync";
+    async function* readEventStream(body2, options = {}) {
+      const reader = body2.getReader();
+      const decoder = new TextDecoder();
+      let buffer = "";
+      try {
+        for (; ; ) {
+          const { value, done } = await readWithin(reader, options.silenceMs);
+          if (done)
+            return;
+          buffer = (buffer + decoder.decode(value, { stream: true })).replace(/\r\n|\r(?!$)/g, "\n");
+          let boundary;
+          while ((boundary = buffer.indexOf("\n\n")) !== -1) {
+            const block = buffer.slice(0, boundary);
+            buffer = buffer.slice(boundary + 2);
+            const message = parseBlock(block);
+            if (message)
+              yield message;
+          }
+        }
+      } finally {
+        await reader.cancel().catch(() => void 0);
+      }
+    }
+    function parseBlock(block) {
+      let id = null;
+      let event = "message";
+      const data = [];
+      for (const line of block.split("\n")) {
+        if (line === "" || line.startsWith(":"))
+          continue;
+        const colon = line.indexOf(":");
+        const field = colon === -1 ? line : line.slice(0, colon);
+        let value = colon === -1 ? "" : line.slice(colon + 1);
+        if (value.startsWith(" "))
+          value = value.slice(1);
+        if (field === "data")
+          data.push(value);
+        else if (field === "event")
+          event = value;
+        else if (field === "id")
+          id = value;
+      }
+      return data.length === 0 ? null : { id, event, data: data.join("\n") };
+    }
+    async function readWithin(reader, silenceMs) {
+      if (silenceMs === void 0)
+        return reader.read();
+      let timer;
+      try {
+        return await Promise.race([
+          reader.read(),
+          new Promise((_, reject) => {
+            timer = setTimeout(() => reject(new StreamSilentError(silenceMs)), silenceMs);
+          })
+        ]);
+      } finally {
+        clearTimeout(timer);
+      }
+    }
+    var StreamSilentError = class extends Error {
+      constructor(silenceMs) {
+        super(`The stream sent nothing for ${silenceMs}ms`);
+        this.name = "StreamSilentError";
+      }
+    };
+    exports2.StreamSilentError = StreamSilentError;
+    function connectStream(options) {
+      const silenceMs = options.silenceMs ?? 45e3;
+      const minMs = options.retry?.minMs ?? 1e3;
+      const maxMs = options.retry?.maxMs ?? 3e4;
+      const sleep = options.sleep ?? abortableSleep;
+      const random = options.random ?? Math.random;
+      const controller = new AbortController();
+      let lastEventId = null;
+      let failures = 0;
+      let status = null;
+      const report = (next) => {
+        if (next === status)
+          return;
+        status = next;
+        options.onStatus?.(next);
+      };
+      const run2 = async () => {
+        while (!controller.signal.aborted) {
+          try {
+            const res = await options.open({ lastEventId }, controller.signal);
+            if (res.status >= 400 && res.status < 500 && res.status !== 408 && res.status !== 429) {
+              await res.body?.cancel().catch(() => void 0);
+              report("stopped");
+              return;
+            }
+            if (!res.ok || !res.body) {
+              await res.body?.cancel().catch(() => void 0);
+              throw new Error(`stream answered ${res.status}`);
+            }
+            report("live");
+            const openedAt = Date.now();
+            for await (const message of readEventStream(res.body, { silenceMs })) {
+              if (controller.signal.aborted)
+                return;
+              if (message.id !== null)
+                lastEventId = message.id;
+              options.onMessage(message);
+            }
+            if (controller.signal.aborted)
+              return;
+            if (Date.now() - openedAt >= minMs) {
+              failures = 0;
+              continue;
+            }
+          } catch {
+            if (controller.signal.aborted)
+              return;
+          }
+          failures += 1;
+          report("reconnecting");
+          const ceiling = Math.min(maxMs, minMs * 2 ** (failures - 1));
+          await sleep(Math.max(minMs / 2, random() * ceiling), controller.signal).catch(() => void 0);
+        }
+      };
+      void run2();
+      return { close: () => controller.abort() };
+    }
+    function abortableSleep(ms, signal) {
+      return new Promise((resolve, reject) => {
+        if (signal.aborted)
+          return reject(signal.reason);
+        const timer = setTimeout(resolve, ms);
+        signal.addEventListener("abort", () => {
+          clearTimeout(timer);
+          reject(signal.reason);
+        }, { once: true });
+      });
+    }
+  }
+});
+
+// ../../packages/realtime-client/dist/index.js
+var require_dist6 = __commonJS({
+  "../../packages/realtime-client/dist/index.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.StreamSilentError = exports2.RESYNC = exports2.readEventStream = exports2.connectStream = void 0;
+    var reader_1 = require_reader();
+    Object.defineProperty(exports2, "connectStream", { enumerable: true, get: function() {
+      return reader_1.connectStream;
+    } });
+    Object.defineProperty(exports2, "readEventStream", { enumerable: true, get: function() {
+      return reader_1.readEventStream;
+    } });
+    Object.defineProperty(exports2, "RESYNC", { enumerable: true, get: function() {
+      return reader_1.RESYNC;
+    } });
+    Object.defineProperty(exports2, "StreamSilentError", { enumerable: true, get: function() {
+      return reader_1.StreamSilentError;
+    } });
+  }
+});
+
 // ../../packages/jobs/dist/subscribe.js
 var require_subscribe = __commonJS({
   "../../packages/jobs/dist/subscribe.js"(exports2) {
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.subscribe = subscribe;
+    var realtime_client_1 = require_dist6();
     var response_1 = require_response();
     var NULL_LOGGER = {
       debug: () => {
@@ -68493,6 +68684,8 @@ var require_subscribe = __commonJS({
       return outcome;
     }
     var STOPPED = Symbol("stopped");
+    var STREAMING_POLL_MS = 3e5;
+    var HINT_JITTER_MS = 250;
     var DECLINE_WINDOW = 25;
     var DECLINED_MEMORY = 1e3;
     function subscribe(opts) {
@@ -68503,6 +68696,12 @@ var require_subscribe = __commonJS({
       let stopped = true;
       let session = 0;
       let pollTimer = null;
+      let nextPollAt = Infinity;
+      let polling = false;
+      let pollAgain = false;
+      let hintStream = null;
+      let streamLive = false;
+      let streamSupported = opts.stream ?? true;
       let inflight = 0;
       let resolvedPoolIds = [];
       const controllers = /* @__PURE__ */ new Map();
@@ -68655,13 +68854,50 @@ var require_subscribe = __commonJS({
           maxConcurrency,
           ...shift ? { shiftId: shift.id } : {}
         });
+        openHintStream(mySession);
         schedulePoll(pollIntervalMs);
       }
+      function openHintStream(mySession) {
+        if (!streamSupported || typeof opts.jobsClient.openHintStream !== "function")
+          return;
+        hintStream = (0, realtime_client_1.connectStream)({
+          open: ({ lastEventId }, signal) => opts.jobsClient.openHintStream({ ...shift ? { shift: shift.id } : {}, lastEventId, signal }),
+          onMessage: (message) => {
+            if (stopped || mySession !== session)
+              return;
+            if (message.event === "jobs.available" && (holds.size > 0 || inflight >= maxConcurrency))
+              return;
+            pollSoon(Math.random() * HINT_JITTER_MS);
+          },
+          onStatus: (status) => {
+            if (mySession !== session)
+              return;
+            streamLive = status === "live";
+            if (status === "stopped") {
+              streamSupported = false;
+              hintStream = null;
+              logger.debug?.("Jobs offers no hint stream; polling instead");
+            }
+            if (!streamLive)
+              pollSoon(pollIntervalMs);
+          }
+        });
+      }
+      function closeHintStream() {
+        hintStream?.close();
+        hintStream = null;
+        streamLive = false;
+      }
       async function startShift() {
         if (!shiftsSupported)
           return;
         try {
+          const previous = shift?.id;
           shift = await opts.jobsClient.startShift();
+          if (hintStream && shift.id !== previous) {
+            closeHintStream();
+            openHintStream(session);
+          }
         } catch (err2) {
           if (isFatal(err2) || isUnavailable(err2) || isRateLimited(err2))
             throw err2;
@@ -68717,6 +68953,8 @@ var require_subscribe = __commonJS({
           clearTimeout(pollTimer);
           pollTimer = null;
         }
+        nextPollAt = Infinity;
+        closeHintStream();
         wakeStartup?.();
       }
       async function stop2(options = {}) {
@@ -68751,15 +68989,41 @@ var require_subscribe = __commonJS({
       }
       function schedulePoll(delayMs) {
         const mySession = session;
-        const checkInMs = shift ? shift.lapseAfterSeconds * 1e3 / 4 : Infinity;
+        const checkInMs = shift && !streamLive ? shift.lapseAfterSeconds * 1e3 / 4 : Infinity;
+        const ms = Math.min(delayMs, checkInMs);
+        if (pollTimer !== null)
+          clearTimeout(pollTimer);
+        nextPollAt = Date.now() + ms;
         pollTimer = setTimeout(() => {
+          pollTimer = null;
+          nextPollAt = Infinity;
           void poll(mySession);
-        }, Math.min(delayMs, checkInMs));
+        }, ms);
+      }
+      function pollSoon(delayMs) {
+        if (stopped)
+          return;
+        if (polling) {
+          pollAgain = true;
+          return;
+        }
+        if (nextPollAt <= Date.now() + delayMs)
+          return;
+        schedulePoll(delayMs);
       }
       async function poll(mySession) {
         if (stopped || mySession !== session)
           return;
-        let nextPollMs = pollIntervalMs;
+        polling = true;
+        pollAgain = false;
+        try {
+          await pollOnce(mySession);
+        } finally {
+          polling = false;
+        }
+      }
+      async function pollOnce(mySession) {
+        let nextPollMs = streamLive ? STREAMING_POLL_MS : pollIntervalMs;
         try {
           const paused = holds.size > 0;
           const free = maxConcurrency - inflight;
@@ -68800,6 +69064,8 @@ var require_subscribe = __commonJS({
               inflight++;
               void runOnce(job).finally(() => {
                 inflight--;
+                if (streamLive)
+                  pollSoon(0);
               });
             }
           }
@@ -68816,8 +69082,9 @@ var require_subscribe = __commonJS({
             logger.error("poll failed", { error: err2 instanceof Error ? err2.message : String(err2) });
           }
         }
-        if (!stopped && mySession === session)
-          schedulePoll(nextPollMs);
+        if (stopped || mySession !== session)
+          return;
+        schedulePoll(pollAgain ? Math.min(nextPollMs, Math.random() * HINT_JITTER_MS) : nextPollMs);
       }
       async function runOnce(available) {
         let dispatch;
@@ -68944,7 +69211,7 @@ var require_subscribe = __commonJS({
 });
 
 // ../../packages/jobs/dist/index.js
-var require_dist6 = __commonJS({
+var require_dist7 = __commonJS({
   "../../packages/jobs/dist/index.js"(exports2) {
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
@@ -69300,7 +69567,7 @@ var require_probes = __commonJS({
     var path_1 = __importDefault(require("path"));
     var yaml_1 = require_dist5();
     var keep_1 = require_dist4();
-    var jobs_1 = require_dist6();
+    var jobs_1 = require_dist7();
     var scaffold_1 = require_scaffold();
     var loader_1 = require_loader();
     var codex_1 = require_codex();
@@ -74184,7 +74451,7 @@ var require_shuttle = __commonJS({
     exports2.resolveAuth = resolveAuth;
     var os_1 = require("os");
     var path_1 = require("path");
-    var jobs_1 = require_dist6();
+    var jobs_1 = require_dist7();
     var self_update_1 = require_self_update();
     var decommission_1 = require_decommission();
     var loom_1 = require_dist();
@@ -75479,7 +75746,7 @@ var require_bundle_assets = __commonJS({
 });
 
 // ../../packages/shuttle/dist/index.js
-var require_dist7 = __commonJS({
+var require_dist8 = __commonJS({
   "../../packages/shuttle/dist/index.js"(exports2) {
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
@@ -75710,14 +75977,14 @@ var require_dist7 = __commonJS({
 });
 
 // src/bin.ts
-var import_shuttle2 = __toESM(require_dist7());
+var import_shuttle2 = __toESM(require_dist8());
 
 // src/brand.ts
 var import_path = require("path");
 var import_promises = require("fs/promises");
 var import_yaml = __toESM(require_dist5());
-var import_shuttle = __toESM(require_dist7());
-var buildVersion = true ? "0.41.2" : pkg.version;
+var import_shuttle = __toESM(require_dist8());
+var buildVersion = true ? "0.42.0" : pkg.version;
 var AGENT_EXECUTORS = ["claude-code", "codex", "copilot"];
 var sifterBrand = {
   product: {