modelstat 0.7.0 → 0.8.0

package/dist/cli.mjs

@@ -125,8 +125,12 @@ async function resolveGitContext(cwd) {
 function guessRepoSlugFromPath(cwd) {
   if (!cwd) return null;
   const m = /\/(?:www|src|code|repos|projects)\/([^/]+)\/([^/]+)/i.exec(cwd);
-  if (m) return `${m[1]}/${m[2]}`;
-  return null;
+  if (!m) return null;
+  const a = m[1];
+  const b = m[2];
+  if (!a || !b) return null;
+  if (b.startsWith(".") || b === "worktrees") return a;
+  return `${a}/${b}`;
 }
 var pexec, cache;
 var init_git = __esm({
@@ -16730,7 +16734,7 @@ var require_client_h2 = __commonJS({
   "../../node_modules/.pnpm/undici@7.25.0/node_modules/undici/lib/dispatcher/client-h2.js"(exports, module) {
     "use strict";
     var assert = __require("assert");
-    var { pipeline } = __require("stream");
+    var { pipeline: pipeline2 } = __require("stream");
     var util2 = require_util();
     var {
       RequestContentLengthMismatchError,
@@ -17363,7 +17367,7 @@ var require_client_h2 = __commonJS({
     }
     function writeStream(abort, socket, expectsPayload, h2stream, body, client, request3, contentLength) {
       assert(contentLength !== 0 || client[kRunning] === 0, "stream body cannot be pipelined");
-      const pipe = pipeline(
+      const pipe = pipeline2(
         body,
         h2stream,
         (err) => {
@@ -18070,10 +18074,10 @@ var require_pool_base = __commonJS({
       [kClients] = [];
       [kNeedDrain] = false;
       [kOnDrain](client, origin, targets) {
-        const queue = this[kQueue];
+        const queue2 = this[kQueue];
         let needDrain = false;
         while (!needDrain) {
-          const item = queue.shift();
+          const item = queue2.shift();
           if (!item) {
             break;
           }
@@ -18085,7 +18089,7 @@ var require_pool_base = __commonJS({
           this[kNeedDrain] = false;
           this.emit("drain", origin, [this, ...targets]);
         }
-        if (this[kClosedResolve] && queue.isEmpty()) {
+        if (this[kClosedResolve] && queue2.isEmpty()) {
           const closeAll = [];
           for (let i = 0; i < this[kClients].length; i++) {
             const client2 = this[kClients][i];
@@ -21129,7 +21133,7 @@ var require_api_pipeline = __commonJS({
         util2.destroy(ret, err);
       }
     };
-    function pipeline(opts, handler) {
+    function pipeline2(opts, handler) {
       try {
         const pipelineHandler = new PipelineHandler(opts, handler);
         this.dispatch({ ...opts, body: pipelineHandler.req }, pipelineHandler);
@@ -21138,7 +21142,7 @@ var require_api_pipeline = __commonJS({
         return new PassThrough().destroy(err);
       }
     }
-    module.exports = pipeline;
+    module.exports = pipeline2;
   }
 });
 
@@ -22010,13 +22014,13 @@ var require_mock_call_history = __commonJS({
     "use strict";
     var { kMockCallHistoryAddLog } = require_mock_symbols();
     var { InvalidArgumentError } = require_errors();
-    function handleFilterCallsWithOptions(criteria, options, handler, store) {
+    function handleFilterCallsWithOptions(criteria, options, handler, store2) {
       switch (options.operator) {
         case "OR":
-          store.push(...handler(criteria));
-          return store;
+          store2.push(...handler(criteria));
+          return store2;
         case "AND":
-          return handler.call({ logs: store }, criteria);
+          return handler.call({ logs: store2 }, criteria);
         default:
           throw new InvalidArgumentError("options.operator must to be a case insensitive string equal to 'OR' or 'AND'");
       }
@@ -24373,12 +24377,12 @@ var require_cache = __commonJS({
       }
       return false;
     }
-    function assertCacheStore(store, name = "CacheStore") {
-      if (typeof store !== "object" || store === null) {
-        throw new TypeError(`expected type of ${name} to be a CacheStore, got ${store === null ? "null" : typeof store}`);
+    function assertCacheStore(store2, name = "CacheStore") {
+      if (typeof store2 !== "object" || store2 === null) {
+        throw new TypeError(`expected type of ${name} to be a CacheStore, got ${store2 === null ? "null" : typeof store2}`);
       }
       for (const fn of ["get", "createWriteStream", "delete"]) {
-        if (typeof store[fn] !== "function") {
+        if (typeof store2[fn] !== "function") {
           throw new TypeError(`${name} needs to have a \`${fn}()\` function`);
         }
       }
@@ -24982,8 +24986,8 @@ var require_cache_handler = __commonJS({
        * @param {import('../../types/cache-interceptor.d.ts').default.CacheKey} cacheKey
        * @param {import('../../types/dispatcher.d.ts').default.DispatchHandler} handler
        */
-      constructor({ store, type, cacheByDefault }, cacheKey, handler) {
-        this.#store = store;
+      constructor({ store: store2, type, cacheByDefault }, cacheKey, handler) {
+        this.#store = store2;
         this.#cacheType = type;
         this.#cacheByDefault = cacheByDefault;
         this.#cacheKey = cacheKey;
@@ -25392,7 +25396,7 @@ var require_memory_cache_store = __commonJS({
         assertCacheKey(key);
         assertCacheValue(val);
         const topLevelKey = `${key.origin}:${key.path}`;
-        const store = this;
+        const store2 = this;
         const entry = { ...key, ...val, body: [], size: 0 };
         return new Writable({
           write(chunk, encoding, callback) {
@@ -25400,7 +25404,7 @@ var require_memory_cache_store = __commonJS({
               chunk = Buffer.from(chunk, encoding);
             }
             entry.size += chunk.byteLength;
-            if (entry.size >= store.#maxEntrySize) {
+            if (entry.size >= store2.#maxEntrySize) {
               this.destroy();
             } else {
               entry.body.push(chunk);
@@ -25408,42 +25412,42 @@ var require_memory_cache_store = __commonJS({
             callback(null);
           },
           final(callback) {
-            let entries = store.#entries.get(topLevelKey);
+            let entries = store2.#entries.get(topLevelKey);
             if (!entries) {
               entries = [];
-              store.#entries.set(topLevelKey, entries);
+              store2.#entries.set(topLevelKey, entries);
             }
             const previousEntry = findEntry(key, entries, Date.now());
             if (previousEntry) {
               const index = entries.indexOf(previousEntry);
               entries.splice(index, 1, entry);
-              store.#size -= previousEntry.size;
+              store2.#size -= previousEntry.size;
             } else {
               entries.push(entry);
-              store.#count += 1;
-            }
-            store.#size += entry.size;
-            if (store.#size > store.#maxSize || store.#count > store.#maxCount) {
-              if (!store.#hasEmittedMaxSizeEvent) {
-                store.emit("maxSizeExceeded", {
-                  size: store.#size,
-                  maxSize: store.#maxSize,
-                  count: store.#count,
-                  maxCount: store.#maxCount
+              store2.#count += 1;
+            }
+            store2.#size += entry.size;
+            if (store2.#size > store2.#maxSize || store2.#count > store2.#maxCount) {
+              if (!store2.#hasEmittedMaxSizeEvent) {
+                store2.emit("maxSizeExceeded", {
+                  size: store2.#size,
+                  maxSize: store2.#maxSize,
+                  count: store2.#count,
+                  maxCount: store2.#maxCount
                 });
-                store.#hasEmittedMaxSizeEvent = true;
+                store2.#hasEmittedMaxSizeEvent = true;
               }
-              for (const [key2, entries2] of store.#entries) {
+              for (const [key2, entries2] of store2.#entries) {
                 for (const entry2 of entries2.splice(0, entries2.length / 2)) {
-                  store.#size -= entry2.size;
-                  store.#count -= 1;
+                  store2.#size -= entry2.size;
+                  store2.#count -= 1;
                 }
                 if (entries2.length === 0) {
-                  store.#entries.delete(key2);
+                  store2.#entries.delete(key2);
                 }
               }
-              if (store.#size < store.#maxSize && store.#count < store.#maxCount) {
-                store.#hasEmittedMaxSizeEvent = false;
+              if (store2.#size < store2.#maxSize && store2.#count < store2.#maxCount) {
+                store2.#hasEmittedMaxSizeEvent = false;
               }
             }
             callback(null);
@@ -25814,7 +25818,7 @@ var require_cache2 = __commonJS({
     }
     module.exports = (opts = {}) => {
       const {
-        store = new MemoryCacheStore(),
+        store: store2 = new MemoryCacheStore(),
         methods = ["GET"],
         cacheByDefault = void 0,
         type = "shared",
@@ -25823,7 +25827,7 @@ var require_cache2 = __commonJS({
       if (typeof opts !== "object" || opts === null) {
         throw new TypeError(`expected type of opts to be an Object, got ${opts === null ? "null" : typeof opts}`);
       }
-      assertCacheStore(store, "opts.store");
+      assertCacheStore(store2, "opts.store");
       assertCacheMethods(methods, "opts.methods");
       assertCacheOrigins(origins, "opts.origins");
       if (typeof cacheByDefault !== "undefined" && typeof cacheByDefault !== "number") {
@@ -25833,7 +25837,7 @@ var require_cache2 = __commonJS({
         throw new TypeError(`expected opts.type to be shared, private, or undefined, got ${typeof type}`);
       }
       const globalOpts = {
-        store,
+        store: store2,
         methods,
         cacheByDefault,
         type
@@ -25872,7 +25876,7 @@ var require_cache2 = __commonJS({
             return dispatch(opts2, handler);
           }
           const cacheKey = makeCacheKey(opts2);
-          const result2 = store.get(cacheKey);
+          const result2 = store2.get(cacheKey);
           if (result2 && typeof result2.then === "function") {
             return result2.then((result3) => handleResult2(
               dispatch,
@@ -25905,7 +25909,7 @@ var require_decompress = __commonJS({
   "../../node_modules/.pnpm/undici@7.25.0/node_modules/undici/lib/interceptor/decompress.js"(exports, module) {
     "use strict";
     var { createInflate, createGunzip, createBrotliDecompress, createZstdDecompress } = __require("zlib");
-    var { pipeline } = __require("stream");
+    var { pipeline: pipeline2 } = __require("stream");
     var DecoratorHandler = require_decorator_handler();
     var { runtimeFeatures } = require_runtime_features();
     var supportedEncodings = {
@@ -26014,7 +26018,7 @@ var require_decompress = __commonJS({
       #setupMultipleDecompressors(controller) {
         const lastDecompressor = this.#decompressors[this.#decompressors.length - 1];
         this.#setupDecompressorEvents(lastDecompressor, controller);
-        pipeline(this.#decompressors, (err) => {
+        pipeline2(this.#decompressors, (err) => {
           if (err) {
             super.onResponseError(controller, err);
             return;
@@ -26805,12 +26809,12 @@ var require_sqlite_cache_store = __commonJS({
         assertCacheValue(value);
         let size = 0;
         const body = [];
-        const store = this;
+        const store2 = this;
         return new Writable({
           decodeStrings: true,
           write(chunk, encoding, callback) {
             size += chunk.byteLength;
-            if (size < store.#maxEntrySize) {
+            if (size < store2.#maxEntrySize) {
               body.push(chunk);
             } else {
               this.destroy();
@@ -26818,7 +26822,7 @@ var require_sqlite_cache_store = __commonJS({
             callback();
           },
           final(callback) {
-            store.set(key, { ...value, body });
+            store2.set(key, { ...value, body });
             callback();
           }
         });
@@ -28754,7 +28758,7 @@ var require_fetch = __commonJS({
       subresourceSet
     } = require_constants3();
     var EE = __require("events");
-    var { Readable: Readable2, pipeline, finished, isErrored, isReadable } = __require("stream");
+    var { Readable: Readable2, pipeline: pipeline2, finished, isErrored, isReadable } = __require("stream");
     var { addAbortListener, bufferToLowerCasedHeaderName } = require_util();
     var { dataURLProcessor, serializeAMimeType, minimizeSupportedMimeType } = require_data_url();
     var { getGlobalDispatcher } = require_global2();
@@ -29745,7 +29749,7 @@ var require_fetch = __commonJS({
                 status: status2,
                 statusText,
                 headersList,
-                body: decoders.length ? pipeline(this.body, ...decoders, (err) => {
+                body: decoders.length ? pipeline2(this.body, ...decoders, (err) => {
                   if (err) {
                     this.onError(err);
                   }
@@ -32218,9 +32222,9 @@ var require_sender = __commonJS({
       }
       async #run() {
         this.#running = true;
-        const queue = this.#queue;
-        while (!queue.isEmpty()) {
-          const node = queue.shift();
+        const queue2 = this.#queue;
+        while (!queue2.isEmpty()) {
+          const node = queue2.shift();
           if (node.promise !== null) {
             await node.promise;
           }
@@ -33379,7 +33383,7 @@ ${value}`;
 var require_eventsource = __commonJS({
   "../../node_modules/.pnpm/undici@7.25.0/node_modules/undici/lib/web/eventsource/eventsource.js"(exports, module) {
     "use strict";
-    var { pipeline } = __require("stream");
+    var { pipeline: pipeline2 } = __require("stream");
     var { fetching } = require_fetch();
     var { makeRequest } = require_request2();
     var { webidl } = require_webidl();
@@ -33537,7 +33541,7 @@ var require_eventsource = __commonJS({
               ));
             }
           });
-          pipeline(
+          pipeline2(
             response.body.stream,
             eventSourceStream,
             (error) => {
@@ -33892,11 +33896,13 @@ function expBackoff(attempt) {
   const i = Math.min(Math.max(attempt, 0), BACKOFF_MS.length - 1);
   return BACKOFF_MS[i];
 }
-var INGEST_BATCH_MAX_EVENTS, BACKOFF_MS, BACKSTOP_SCAN_MS;
+var INGEST_BATCH_MAX_EVENTS, SESSION_DEBOUNCE_MS, FORCE_SHIP_THRESHOLD, BACKOFF_MS, BACKSTOP_SCAN_MS;
 var init_config = __esm({
   "../../packages/daemon-core/src/config/index.ts"() {
     "use strict";
     INGEST_BATCH_MAX_EVENTS = 1e3;
+    SESSION_DEBOUNCE_MS = 7e3;
+    FORCE_SHIP_THRESHOLD = 200;
     BACKOFF_MS = [1e3, 2500, 5e3, 1e4, 2e4, 6e4];
     BACKSTOP_SCAN_MS = 5 * 6e4;
   }
@@ -34886,7 +34892,7 @@ async function fetchDeviceViewLedgerByClaim(claimCode) {
 }
 function ingestClient() {
   if (_ingest) return _ingest;
-  const logger = createLogger("daemon.ingest");
+  const logger2 = createLogger("daemon.ingest");
   _ingest = new IngestClient({
     apiUrl: state.apiUrl,
     auth: {
@@ -34902,7 +34908,7 @@ function ingestClient() {
         }
       }
     },
-    logger
+    logger: logger2
   });
   return _ingest;
 }
@@ -35083,17 +35089,101 @@ var init_ids2 = __esm({
 });
 
 // ../../packages/daemon-core/src/queue/index.ts
+async function buildBatches(opts) {
+  const debounceMs = opts.debounceMs ?? SESSION_DEBOUNCE_MS;
+  const maxEvents = opts.maxEvents ?? INGEST_BATCH_MAX_EVENTS;
+  const forceThreshold = opts.forceShipThreshold ?? FORCE_SHIP_THRESHOLD;
+  const bySession = await opts.store.listUnsentBySession();
+  const batches = [];
+  let eventsInCurrentBatch = [];
+  let sessionIdsInCurrentBatch = [];
+  let toolCallsInCurrentBatch = [];
+  for (const [, items] of bySession) {
+    if (items.length === 0) continue;
+    const lastTs = Math.max(...items.map((i) => i.last_event_ts_ms));
+    const quiet = opts.nowMs - lastTs >= debounceMs;
+    if (!quiet && items.length < forceThreshold) continue;
+    for (const item of items) {
+      const itemCalls = item.tool_calls ?? [];
+      if (eventsInCurrentBatch.length >= maxEvents || eventsInCurrentBatch.length > 0 && toolCallsInCurrentBatch.length + itemCalls.length > INGEST_BATCH_MAX_TOOL_CALLS) {
+        batches.push(
+          await finalise({
+            events: eventsInCurrentBatch,
+            sessionIds: sessionIdsInCurrentBatch,
+            toolCalls: toolCallsInCurrentBatch,
+            pipeline: opts.pipeline,
+            deviceId: opts.deviceId,
+            daemonVersion: opts.daemonVersion
+          })
+        );
+        eventsInCurrentBatch = [];
+        sessionIdsInCurrentBatch = [];
+        toolCallsInCurrentBatch = [];
+      }
+      eventsInCurrentBatch.push(item.event);
+      sessionIdsInCurrentBatch.push(item.session_id);
+      toolCallsInCurrentBatch.push(...itemCalls);
+    }
+  }
+  if (eventsInCurrentBatch.length > 0) {
+    batches.push(
+      await finalise({
+        events: eventsInCurrentBatch,
+        sessionIds: sessionIdsInCurrentBatch,
+        toolCalls: toolCallsInCurrentBatch,
+        pipeline: opts.pipeline,
+        deviceId: opts.deviceId,
+        daemonVersion: opts.daemonVersion
+      })
+    );
+  }
+  return batches;
+}
+function attachSegmentIds(calls, segments) {
+  const segmentByEvent = /* @__PURE__ */ new Map();
+  for (const seg of segments) {
+    for (const id of seg.source_event_ids) segmentByEvent.set(id, seg.segment_id);
+  }
+  return attachSegmentIdsByMap(calls, segmentByEvent);
+}
 function attachSegmentIdsByMap(calls, segmentByEvent) {
   return calls.map((c) => ({
     ...c,
     segment_id: segmentByEvent.get(c.source_event_id) ?? null
   }));
 }
+async function finalise(args) {
+  const segments = [];
+  const bySession = /* @__PURE__ */ new Map();
+  for (let i = 0; i < args.events.length; i++) {
+    const sid = args.sessionIds[i] ?? args.events[i]?.session_id ?? "unknown";
+    const arr = bySession.get(sid) ?? [];
+    const ev = args.events[i];
+    if (ev) arr.push(ev);
+    bySession.set(sid, arr);
+  }
+  for (const [, sessionEvents] of bySession) {
+    const segs = await args.pipeline.run(sessionEvents);
+    segments.push(...segs);
+  }
+  return {
+    batch_id: batchId(),
+    device_id: args.deviceId,
+    daemon_version: args.daemonVersion,
+    events: args.events,
+    segments,
+    // Segments are in hand here, so segment attribution happens at the
+    // last responsible moment before the wire.
+    tool_calls: attachSegmentIds(args.toolCalls, segments)
+  };
+}
+var INGEST_BATCH_MAX_TOOL_CALLS;
 var init_queue = __esm({
   "../../packages/daemon-core/src/queue/index.ts"() {
     "use strict";
     init_config();
     init_ids2();
+    INGEST_BATCH_MAX_TOOL_CALLS = 2e4;
   }
 });
 
@@ -37086,7 +37176,7 @@ var init_scan = __esm({
     init_api();
     init_config2();
     init_pipeline2();
-    DAEMON_VERSION = true ? "daemon-0.7.0" : "daemon-dev";
+    DAEMON_VERSION = true ? "daemon-0.8.0" : "daemon-dev";
     BATCH_MAX_EVENTS = INGEST_BATCH_MAX_EVENTS;
     BATCH_MAX_TOOL_CALLS = 2e4;
     BATCH_BUFFER_HARD_CAP = BATCH_MAX_EVENTS * 2;
@@ -37323,6 +37413,165 @@ var init_update = __esm({
   }
 });
 
+// src/receiver.ts
+import { createServer } from "http";
+function queue() {
+  if (!store) store = new FileQueueStore(homePath("sdk-ingest-queue.json"));
+  return store;
+}
+function parseBatch(json) {
+  if (typeof json !== "object" || json === null) return { error: "body must be a JSON object" };
+  const b = json;
+  if (!Array.isArray(b.events) || b.events.length === 0)
+    return { error: "events must be a non-empty array" };
+  if (b.events.length > 1e4) return { error: "too many events (max 10000)" };
+  for (const e of b.events) {
+    if (typeof e !== "object" || e === null) return { error: "each event must be an object" };
+    const ev = e;
+    for (const k of ["source_event_id", "session_id", "agent", "ts"]) {
+      if (typeof ev[k] !== "string" || ev[k].length === 0)
+        return { error: `event.${k} is required` };
+    }
+  }
+  const toolCalls = Array.isArray(b.tool_calls) ? b.tool_calls : [];
+  return { events: b.events, toolCalls };
+}
+async function enqueue(batch) {
+  const q = queue();
+  for (const event of batch.events) {
+    const calls = batch.toolCalls.filter((tc) => tc.source_event_id === event.source_event_id).map(({ segment_id: _segmentId, ...draft }) => draft);
+    await q.put({
+      source_event_id: event.source_event_id,
+      session_id: event.session_id,
+      agent: event.agent,
+      event,
+      last_event_ts_ms: Date.parse(event.ts) || Date.now(),
+      synced: false,
+      sent_batch_id: null,
+      tool_calls: calls.length > 0 ? calls : void 0
+    });
+  }
+  return batch.events.length;
+}
+async function drainLocalQueue(opts) {
+  if (draining) return { batches: 0, events: 0 };
+  draining = true;
+  try {
+    const q = queue();
+    if (await q.countUnsent() === 0) return { batches: 0, events: 0 };
+    const batches = await buildBatches({
+      store: q,
+      pipeline,
+      deviceId: opts.deviceId,
+      daemonVersion: opts.daemonVersion,
+      nowMs: Date.now()
+    });
+    let events = 0;
+    for (const batch of batches) {
+      const shipped = {
+        ...batch,
+        events: batch.events.map(({ content_excerpt: _excerpt, ...rest }) => rest)
+      };
+      await uploadBatch(shipped);
+      await q.markSent(
+        batch.events.map((e) => e.source_event_id),
+        batch.batch_id
+      );
+      events += batch.events.length;
+    }
+    return { batches: batches.length, events };
+  } finally {
+    draining = false;
+  }
+}
+function localQueueDepth() {
+  return queue().countUnsent();
+}
+function startLocalIngestReceiver(opts = {}) {
+  const port = opts.port ?? (Number(process.env.MODELSTAT_LOCAL_INGEST_PORT) || DEFAULT_LOCAL_INGEST_PORT);
+  return new Promise((resolve6) => {
+    const server = createServer((req, res) => void handle(req, res));
+    let settled = false;
+    server.on("error", (err) => {
+      if (settled) return;
+      settled = true;
+      logger.warn(
+        `local ingest receiver disabled \u2014 SDK local_daemon mode unavailable: ${err.code ?? err.message} on 127.0.0.1:${port}`
+      );
+      resolve6(null);
+    });
+    server.listen(port, "127.0.0.1", () => {
+      settled = true;
+      const addr = server.address();
+      const boundPort = typeof addr === "object" && addr ? addr.port : port;
+      logger.info(`local ingest receiver on http://127.0.0.1:${boundPort}/v1/ingest`);
+      resolve6({
+        port: boundPort,
+        close: () => new Promise((r) => server.close(() => r()))
+      });
+    });
+  });
+}
+async function handle(req, res) {
+  const send = (code, body) => {
+    res.writeHead(code, { "content-type": "application/json" });
+    res.end(JSON.stringify(body));
+  };
+  const path = (req.url ?? "").split("?")[0];
+  if (req.method === "GET" && path === "/healthz") return send(200, { ok: true });
+  if (req.method !== "POST" || path !== "/v1/ingest" && path !== "/v1/ingest/raw") {
+    return send(404, { error: "not found" });
+  }
+  let size = 0;
+  const chunks = [];
+  try {
+    for await (const chunk of req) {
+      size += chunk.length;
+      if (size > MAX_BODY_BYTES) {
+        send(413, { error: "batch too large" });
+        req.destroy();
+        return;
+      }
+      chunks.push(chunk);
+    }
+  } catch {
+    return send(400, { error: "read error" });
+  }
+  let json;
+  try {
+    json = JSON.parse(Buffer.concat(chunks).toString("utf8"));
+  } catch {
+    return send(400, { error: "invalid json" });
+  }
+  const parsed = parseBatch(json);
+  if ("error" in parsed) return send(400, parsed);
+  try {
+    const accepted = await enqueue(parsed);
+    return send(200, { accepted, queued: true });
+  } catch (e) {
+    logger.warn(`local ingest enqueue failed: ${e.message}`);
+    return send(500, { error: "enqueue failed" });
+  }
+}
+var logger, DEFAULT_LOCAL_INGEST_PORT, MAX_BODY_BYTES, store, pipeline, draining;
+var init_receiver = __esm({
+  "src/receiver.ts"() {
+    "use strict";
+    init_logger();
+    init_node();
+    init_queue();
+    init_api();
+    init_paths();
+    init_pipeline2();
+    logger = createLogger("daemon.local-ingest");
+    DEFAULT_LOCAL_INGEST_PORT = 4319;
+    MAX_BODY_BYTES = 16 * 1024 * 1024;
+    store = null;
+    pipeline = { run: (events) => buildSegments(events) };
+    draining = false;
+  }
+});
+
 // src/reconcile.ts
 import { stat as stat3 } from "fs/promises";
 function utcDay(ts) {
@@ -37700,19 +37949,19 @@ function createPolicyRefresher(opts) {
     ...opts.fetch ? { fetch: opts.fetch } : {},
     ...opts.logger ? { logger: opts.logger } : {}
   };
-  const store = new RemoteConfigStore(env, [policiesKind]);
+  const store2 = new RemoteConfigStore(env, [policiesKind]);
   let timer = null;
   const apply = () => {
-    const bundle = store.get("policies");
+    const bundle = store2.get("policies");
     setRemoteRedactionPatterns(compilePolicyPatterns(bundle));
   };
   const refresh = async () => {
-    await store.refresh("policies");
+    await store2.refresh("policies");
     apply();
   };
   return {
     async start() {
-      await store.initFromCache();
+      await store2.initFromCache();
       apply();
       void refresh().catch(() => {
       });
@@ -39739,6 +39988,25 @@ async function runDaemon(opts = {}) {
     setPhase("error", `summariser preflight failed: ${err.message}`);
     throw err;
   }
+  const localIngest = await startLocalIngestReceiver();
+  const LOCAL_DRAIN_INTERVAL_MS = 5e3;
+  let localDrainTimer = null;
+  if (localIngest) {
+    const drainTick = async () => {
+      try {
+        const { events } = await drainLocalQueue({
+          deviceId: state.deviceId,
+          daemonVersion: DAEMON_VERSION2
+        });
+        if (events > 0) bumpStat("sdk_events_uploaded", events);
+        setStat("sdk_queue", await localQueueDepth());
+      } catch (e) {
+        setMessage(`SDK ingest upload deferred: ${describeErrorWithCause(e)}`);
+      }
+    };
+    localDrainTimer = setInterval(() => void drainTick(), LOCAL_DRAIN_INTERVAL_MS);
+    localDrainTimer.unref();
+  }
   const { reconcileProcessingVersion: reconcileProcessingVersion2 } = await Promise.resolve().then(() => (init_processing_version(), processing_version_exports));
   const pv = reconcileProcessingVersion2(state);
   if (pv.changed) {
@@ -39805,6 +40073,8 @@ async function runDaemon(opts = {}) {
     setPhase("offline", "Shutting down");
     await sendHeartbeat();
     await watcher.close();
+    if (localDrainTimer) clearInterval(localDrainTimer);
+    await localIngest?.close();
     try {
       const { disposeLlama: disposeLlama2 } = await Promise.resolve().then(() => (init_node(), node_exports));
       await disposeLlama2();
@@ -39828,11 +40098,12 @@ var init_daemon = __esm({
     init_config2();
     init_lock();
     init_machine_key();
+    init_receiver();
     init_reconcile();
     init_scan();
     init_single_flight();
     init_update();
-    DAEMON_VERSION2 = true ? "daemon-0.7.0" : "daemon-dev";
+    DAEMON_VERSION2 = true ? "daemon-0.8.0" : "daemon-dev";
     HEARTBEAT_INTERVAL_MS = 1e4;
     SCAN_INTERVAL_MS = 5 * 60 * 1e3;
     DISCOVERY_INTERVAL_MS = 6e4;
@@ -40436,7 +40707,7 @@ function tryOpenBrowser(url) {
     return false;
   }
 }
-var DAEMON_VERSION3 = true ? "daemon-0.7.0" : "daemon-dev";
+var DAEMON_VERSION3 = true ? "daemon-0.8.0" : "daemon-dev";
 function osFamily() {
   const p = platform6();
   if (p === "darwin") return "macos";