@circuitwall/jarela 2.2.1 → 2.4.0

package/.next/standalone/.next/server/app/api/v1/threads/[thread_id]/activity/route.js

@@ -0,0 +1,1436 @@
+"use strict";
+(() => {
+var exports = {};
+exports.id = 7548;
+exports.ids = [3944,7548];
+exports.modules = {
+
+/***/ 261:
+/***/ ((module) => {
+
+module.exports = require("next/dist/shared/lib/router/utils/app-paths");
+
+/***/ }),
+
+/***/ 1195:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   GET: () => (/* binding */ GET)
+/* harmony export */ });
+/* harmony import */ var next_server__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(23211);
+/* harmony import */ var _lib_stores_threads__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(83042);
+/* harmony import */ var _lib_agents_thread_activity__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(63541);
+/**
+ * UI-internal — `GET /api/v1/threads/[thread_id]/activity`
+ *
+ * One snapshot of what the thread is doing (agent turn phase, queued turns,
+ * compaction), polled by the chat so it can show and resume activity that
+ * started elsewhere: the scheduler, a watcher, a bridge, or another device.
+ */ 
+
+
+async function GET(_req, { params }) {
+    const { thread_id } = await params;
+    if (!(0,_lib_stores_threads__WEBPACK_IMPORTED_MODULE_1__/* .getThread */ .fG)(thread_id)) return next_server__WEBPACK_IMPORTED_MODULE_0__.NextResponse.json({
+        error: "Thread not found"
+    }, {
+        status: 404
+    });
+    return next_server__WEBPACK_IMPORTED_MODULE_0__.NextResponse.json((0,_lib_agents_thread_activity__WEBPACK_IMPORTED_MODULE_2__/* .getThreadActivity */ .C)(thread_id), {
+        headers: {
+            "Cache-Control": "no-store"
+        }
+    });
+}
+
+
+/***/ }),
+
+/***/ 1708:
+/***/ ((module) => {
+
+module.exports = require("node:process");
+
+/***/ }),
+
+/***/ 1932:
+/***/ ((module) => {
+
+module.exports = require("url");
+
+/***/ }),
+
+/***/ 3295:
+/***/ ((module) => {
+
+module.exports = require("next/dist/server/app-render/after-task-async-storage.external.js");
+
+/***/ }),
+
+/***/ 3944:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   M6: () => (/* binding */ enqueueThreadRun),
+/* harmony export */   Zm: () => (/* binding */ QueueFullError),
+/* harmony export */   getQueueDepth: () => (/* binding */ getQueueDepth),
+/* harmony export */   vR: () => (/* binding */ QueueExpiredError)
+/* harmony export */ });
+/* unused harmony export __resetForTests */
+/* harmony import */ var _lib_utils_global_state__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(15559);
+// Per-thread priority queue for agent runs.
+//
+// A thread can have one active run. Waiting interactive runs are selected
+// before waiting background runs, while FIFO order is preserved within each
+// lane. Different threads drain independently.
+//
+// In-memory + single-process. Multi-instance deployment would need a shared
+// lock (Redis, Postgres advisory locks) — explicitly out of scope.
+
+const queues = (0,_lib_utils_global_state__WEBPACK_IMPORTED_MODULE_0__/* .getOrCreateGlobal */ .X)("__jarela_thread_run_queues", ()=>new Map());
+const DEFAULT_MAX_DEPTH = 16;
+const sourceLanes = {
+    user: "interactive",
+    bridge: "interactive",
+    delegate: "interactive",
+    scheduler: "background",
+    watcher: "background",
+    trigger: "background",
+    extension: "background"
+};
+class QueueFullError extends Error {
+    constructor(thread_id, depth){
+        super(`Per-thread run queue full for thread ${thread_id} (depth=${depth})`);
+        this.name = "QueueFullError";
+    }
+}
+class QueueExpiredError extends Error {
+    constructor(thread_id, expiresAt){
+        super(`Queued run expired for thread ${thread_id} at ${expiresAt}`);
+        this.name = "QueueExpiredError";
+    }
+}
+function depth(queue) {
+    return (queue.active ? 1 : 0) + queue.interactive.length + queue.background.length;
+}
+function drain(thread_id, queue) {
+    if (queue.active) return;
+    const job = queue.interactive.shift() ?? queue.background.shift();
+    if (!job) {
+        if (queues.get(thread_id) === queue) queues.delete(thread_id);
+        return;
+    }
+    queue.active = job;
+    Promise.resolve().then(()=>{
+        if (job.expiresAt !== undefined && Date.now() >= job.expiresAt) {
+            throw new QueueExpiredError(thread_id, job.expiresAt);
+        }
+        return job.runner();
+    }).then((value)=>{
+        finish(thread_id, queue);
+        job.resolve(value);
+    }, (error)=>{
+        finish(thread_id, queue);
+        job.reject(error);
+    });
+}
+function finish(thread_id, queue) {
+    queue.active = undefined;
+    if (queues.get(thread_id) === queue) drain(thread_id, queue);
+}
+function enqueueThreadRun(thread_id, source, runner, options = {}) {
+    const queue = queues.get(thread_id) ?? {
+        interactive: [],
+        background: []
+    };
+    const currentDepth = depth(queue);
+    const max = options.maxDepth ?? DEFAULT_MAX_DEPTH;
+    if (currentDepth >= max) {
+        throw new QueueFullError(thread_id, currentDepth);
+    }
+    const lane = options.lane ?? sourceLanes[source];
+    const position = queue.active ? 1 + queue.interactive.length + (lane === "background" ? queue.background.length : 0) : queue.interactive.length + (lane === "background" ? queue.background.length : 0);
+    let resolve;
+    let reject;
+    const result = new Promise((res, rej)=>{
+        resolve = res;
+        reject = rej;
+    });
+    const job = {
+        runner,
+        expiresAt: options.expiresAt,
+        resolve,
+        reject
+    };
+    queue[lane].push(job);
+    queues.set(thread_id, queue);
+    drain(thread_id, queue);
+    return {
+        result,
+        position
+    };
+}
+/** Current queue depth for a thread, including the active job. */ function getQueueDepth(thread_id) {
+    const queue = queues.get(thread_id);
+    return queue ? depth(queue) : 0;
+}
+/** Reset all queue state. Test-only — never call from production code. */ function __resetForTests() {
+    queues.clear();
+}
+
+
+/***/ }),
+
+/***/ 8128:
+/***/ ((module) => {
+
+module.exports = require("next/dist/server/runtime-reacts.external.js");
+
+/***/ }),
+
+/***/ 9956:
+/***/ ((module) => {
+
+module.exports = require("undici");
+
+/***/ }),
+
+/***/ 10846:
+/***/ ((module) => {
+
+module.exports = require("next/dist/compiled/next-server/app-page.runtime.prod.js");
+
+/***/ }),
+
+/***/ 11075:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   handler: () => (/* binding */ handler),
+/* harmony export */   patchFetch: () => (/* binding */ patchFetch),
+/* harmony export */   routeModule: () => (/* binding */ routeModule),
+/* harmony export */   serverHooks: () => (/* binding */ serverHooks),
+/* harmony export */   workAsyncStorage: () => (/* binding */ workAsyncStorage),
+/* harmony export */   workUnitAsyncStorage: () => (/* binding */ workUnitAsyncStorage)
+/* harmony export */ });
+/* harmony import */ var next_dist_server_route_modules_app_route_module_compiled__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(19225);
+/* harmony import */ var next_dist_server_route_modules_app_route_module_compiled__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(next_dist_server_route_modules_app_route_module_compiled__WEBPACK_IMPORTED_MODULE_0__);
+/* harmony import */ var next_dist_server_route_kind__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(84006);
+/* harmony import */ var next_dist_server_lib_patch_fetch__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(8317);
+/* harmony import */ var next_dist_server_lib_patch_fetch__WEBPACK_IMPORTED_MODULE_2___default = /*#__PURE__*/__webpack_require__.n(next_dist_server_lib_patch_fetch__WEBPACK_IMPORTED_MODULE_2__);
+/* harmony import */ var next_dist_server_request_meta__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(99373);
+/* harmony import */ var next_dist_server_request_meta__WEBPACK_IMPORTED_MODULE_3___default = /*#__PURE__*/__webpack_require__.n(next_dist_server_request_meta__WEBPACK_IMPORTED_MODULE_3__);
+/* harmony import */ var next_dist_server_lib_trace_tracer__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(34775);
+/* harmony import */ var next_dist_server_lib_trace_tracer__WEBPACK_IMPORTED_MODULE_4___default = /*#__PURE__*/__webpack_require__.n(next_dist_server_lib_trace_tracer__WEBPACK_IMPORTED_MODULE_4__);
+/* harmony import */ var next_dist_server_app_render_manifests_singleton__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(24235);
+/* harmony import */ var next_dist_server_app_render_manifests_singleton__WEBPACK_IMPORTED_MODULE_5___default = /*#__PURE__*/__webpack_require__.n(next_dist_server_app_render_manifests_singleton__WEBPACK_IMPORTED_MODULE_5__);
+/* harmony import */ var next_dist_shared_lib_router_utils_app_paths__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(261);
+/* harmony import */ var next_dist_shared_lib_router_utils_app_paths__WEBPACK_IMPORTED_MODULE_6___default = /*#__PURE__*/__webpack_require__.n(next_dist_shared_lib_router_utils_app_paths__WEBPACK_IMPORTED_MODULE_6__);
+/* harmony import */ var next_dist_server_base_http_node__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(54365);
+/* harmony import */ var next_dist_server_base_http_node__WEBPACK_IMPORTED_MODULE_7___default = /*#__PURE__*/__webpack_require__.n(next_dist_server_base_http_node__WEBPACK_IMPORTED_MODULE_7__);
+/* harmony import */ var next_dist_server_web_spec_extension_adapters_next_request__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(90771);
+/* harmony import */ var next_dist_server_web_spec_extension_adapters_next_request__WEBPACK_IMPORTED_MODULE_8___default = /*#__PURE__*/__webpack_require__.n(next_dist_server_web_spec_extension_adapters_next_request__WEBPACK_IMPORTED_MODULE_8__);
+/* harmony import */ var next_dist_server_lib_trace_constants__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(73461);
+/* harmony import */ var next_dist_server_lib_trace_constants__WEBPACK_IMPORTED_MODULE_9___default = /*#__PURE__*/__webpack_require__.n(next_dist_server_lib_trace_constants__WEBPACK_IMPORTED_MODULE_9__);
+/* harmony import */ var next_dist_server_instrumentation_utils__WEBPACK_IMPORTED_MODULE_10__ = __webpack_require__(67798);
+/* harmony import */ var next_dist_server_send_response__WEBPACK_IMPORTED_MODULE_11__ = __webpack_require__(92280);
+/* harmony import */ var next_dist_server_web_utils__WEBPACK_IMPORTED_MODULE_12__ = __webpack_require__(62018);
+/* harmony import */ var next_dist_server_web_utils__WEBPACK_IMPORTED_MODULE_12___default = /*#__PURE__*/__webpack_require__.n(next_dist_server_web_utils__WEBPACK_IMPORTED_MODULE_12__);
+/* harmony import */ var next_dist_server_lib_cache_control__WEBPACK_IMPORTED_MODULE_13__ = __webpack_require__(45696);
+/* harmony import */ var next_dist_lib_constants__WEBPACK_IMPORTED_MODULE_14__ = __webpack_require__(47929);
+/* harmony import */ var next_dist_lib_constants__WEBPACK_IMPORTED_MODULE_14___default = /*#__PURE__*/__webpack_require__.n(next_dist_lib_constants__WEBPACK_IMPORTED_MODULE_14__);
+/* harmony import */ var next_dist_shared_lib_no_fallback_error_external__WEBPACK_IMPORTED_MODULE_15__ = __webpack_require__(86439);
+/* harmony import */ var next_dist_shared_lib_no_fallback_error_external__WEBPACK_IMPORTED_MODULE_15___default = /*#__PURE__*/__webpack_require__.n(next_dist_shared_lib_no_fallback_error_external__WEBPACK_IMPORTED_MODULE_15__);
+/* harmony import */ var next_dist_server_lib_route_cache_key__WEBPACK_IMPORTED_MODULE_16__ = __webpack_require__(10246);
+/* harmony import */ var next_dist_server_lib_route_cache_key__WEBPACK_IMPORTED_MODULE_16___default = /*#__PURE__*/__webpack_require__.n(next_dist_server_lib_route_cache_key__WEBPACK_IMPORTED_MODULE_16__);
+/* harmony import */ var next_dist_server_response_cache__WEBPACK_IMPORTED_MODULE_17__ = __webpack_require__(37527);
+/* harmony import */ var next_dist_server_response_cache__WEBPACK_IMPORTED_MODULE_17___default = /*#__PURE__*/__webpack_require__.n(next_dist_server_response_cache__WEBPACK_IMPORTED_MODULE_17__);
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+// We inject the nextConfigOutput here so that we can use them in the route
+// module.
+const nextConfigOutput = "standalone"
+const routeModule = new next_dist_server_route_modules_app_route_module_compiled__WEBPACK_IMPORTED_MODULE_0__.AppRouteRouteModule({
+    definition: {
+        kind: next_dist_server_route_kind__WEBPACK_IMPORTED_MODULE_1__.RouteKind.APP_ROUTE,
+        page: "/api/v1/threads/[thread_id]/activity/route",
+        pathname: "/api/v1/threads/[thread_id]/activity",
+        filename: "route",
+        bundlePath: "app/api/v1/threads/[thread_id]/activity/route"
+    },
+    distDir: ".next" || 0,
+    relativeProjectDir:  false || '',
+    resolvedPagePath: "/home/runner/work/jarela/jarela/app/api/v1/threads/[thread_id]/activity/route.ts",
+    nextConfigOutput,
+    // The lazy require factory ensures that:
+    // - In dev: devRequestTimingInternalsEnd is set before userland executes,
+    //   correctly attributing module load time to application-code rather than
+    //   framework internals.
+    // - In all modes: async modules (route files with top-level await) are
+    //   handled correctly — require() returns a Promise for such modules, which
+    //   ensureUserland() awaits before the first request is handled.
+    userland: ()=>__webpack_require__(1195),
+    // In Turbopack dev mode, also provide a synchronous per-request getter so
+    // server HMR updates are picked up without re-executing the entry chunk.
+    // Using require() (synchronous) avoids adding async overhead that would be
+    // incorrectly attributed to application-code time in devRequestTiming.
+    ... false ? 0 : {}
+});
+// Pull out the exports that we need to expose from the module. This should
+// be eliminated when we've moved the other routes to the new format. These
+// are used to hook into the route.
+const { workAsyncStorage, workUnitAsyncStorage, serverHooks } = routeModule;
+function patchFetch() {
+    return (0,next_dist_server_lib_patch_fetch__WEBPACK_IMPORTED_MODULE_2__.patchFetch)({
+        workAsyncStorage,
+        workUnitAsyncStorage
+    });
+}
+
+async function handler(req, res, ctx) {
+    if (ctx.requestMeta) {
+        (0,next_dist_server_request_meta__WEBPACK_IMPORTED_MODULE_3__.setRequestMeta)(req, ctx.requestMeta);
+    }
+    if (routeModule.isDev) {
+        (0,next_dist_server_request_meta__WEBPACK_IMPORTED_MODULE_3__.addRequestMeta)(req, 'devRequestTimingInternalsEnd', process.hrtime.bigint());
+    }
+    let srcPage = "/api/v1/threads/[thread_id]/activity/route";
+    // turbopack doesn't normalize `/index` in the page name
+    // so we need to to process dynamic routes properly
+    // TODO: fix turbopack providing differing value from webpack
+    if (false) {} else if (srcPage === '/index') {
+        // we always normalize /index specifically
+        srcPage = '/';
+    }
+    const multiZoneDraftMode = false;
+    const prepareResult = await routeModule.prepare(req, res, {
+        srcPage,
+        multiZoneDraftMode
+    });
+    if (!prepareResult) {
+        res.statusCode = 400;
+        res.end('Bad Request');
+        ctx.waitUntil == null ? void 0 : ctx.waitUntil.call(ctx, Promise.resolve());
+        return null;
+    }
+    const { buildId, deploymentId, params, nextConfig, parsedUrl, isDraftMode, prerenderManifest, routerServerContext, isOnDemandRevalidate, revalidateOnlyGenerated, resolvedPathname, clientReferenceManifest, serverActionsManifest, previewProps } = prepareResult;
+    const normalizedSrcPage = (0,next_dist_shared_lib_router_utils_app_paths__WEBPACK_IMPORTED_MODULE_6__.normalizeAppPath)(srcPage);
+    // Only this route's prerenders can establish ISR or admit generated params.
+    const isPrerendered = Boolean(prerenderManifest.routes[resolvedPathname]) && (routeModule.isDev || (0,next_dist_server_lib_route_cache_key__WEBPACK_IMPORTED_MODULE_16__.isRouteCacheOwner)(resolvedPathname, routeModule.cacheOwner, prerenderManifest.routes[resolvedPathname]));
+    let isIsr = Boolean(prerenderManifest.dynamicRoutes[normalizedSrcPage] || isPrerendered);
+    const render404 = async ()=>{
+        // TODO: should route-module itself handle rendering the 404
+        if (routerServerContext == null ? void 0 : routerServerContext.render404) {
+            await routerServerContext.render404(req, res, parsedUrl, false);
+        } else {
+            res.end('This page could not be found');
+        }
+        return null;
+    };
+    if (isIsr && !isDraftMode) {
+        const prerenderInfo = prerenderManifest.dynamicRoutes[normalizedSrcPage];
+        if (prerenderInfo) {
+            if (prerenderInfo.fallback === false && !isPrerendered) {
+                if (nextConfig.adapterPath) {
+                    return await render404();
+                }
+                throw new next_dist_shared_lib_no_fallback_error_external__WEBPACK_IMPORTED_MODULE_15__.NoFallbackError();
+            }
+        }
+    }
+    let cacheKey = null;
+    if (isIsr && !routeModule.isDev && !isDraftMode) {
+        cacheKey = resolvedPathname;
+        // ensure /index and / is normalized to one key
+        cacheKey = cacheKey === '/index' ? '/' : cacheKey;
+    }
+    // Before rendering (which initializes component tree modules), we have to
+    // set the reference manifests to our global store so Server Action's
+    // encryption util can access to them at the top level of the page module.
+    if (serverActionsManifest && clientReferenceManifest) {
+        (0,next_dist_server_app_render_manifests_singleton__WEBPACK_IMPORTED_MODULE_5__.setManifestsSingleton)({
+            page: srcPage,
+            clientReferenceManifest,
+            serverActionsManifest
+        });
+    }
+    const method = req.method || 'GET';
+    const tracer = (0,next_dist_server_lib_trace_tracer__WEBPACK_IMPORTED_MODULE_4__.getTracer)();
+    const activeSpan = tracer.getActiveScopeSpan();
+    const isWrappedByNextServer = Boolean(routerServerContext == null ? void 0 : routerServerContext.isWrappedByNextServer);
+    const isMinimalMode = Boolean((0,next_dist_server_request_meta__WEBPACK_IMPORTED_MODULE_3__.getRequestMeta)(req, 'minimalMode'));
+    const incrementalCache = (0,next_dist_server_request_meta__WEBPACK_IMPORTED_MODULE_3__.getRequestMeta)(req, 'incrementalCache') || await routeModule.getIncrementalCache(req, nextConfig, previewProps, prerenderManifest, isMinimalMode);
+    incrementalCache == null ? void 0 : incrementalCache.resetRequestCache();
+    globalThis.__incrementalCache = incrementalCache;
+    const context = {
+        params,
+        previewProps,
+        renderOpts: {
+            experimental: {
+                authInterrupts: Boolean(nextConfig.experimental.authInterrupts),
+                useCacheTimeout: nextConfig.experimental.useCacheTimeout,
+                durableUseCacheEntries: Boolean(nextConfig.experimental.durableUseCacheEntries)
+            },
+            cacheComponents: Boolean(nextConfig.cacheComponents),
+            validationLevel: nextConfig.experimental.instantInsights.validationLevel,
+            isDraftMode,
+            incrementalCache,
+            hmrRefreshHash: (0,next_dist_server_request_meta__WEBPACK_IMPORTED_MODULE_3__.getRequestMeta)(req, 'hmrRefreshHash'),
+            cacheLifeProfiles: nextConfig.cacheLife,
+            staticPageGenerationTimeout: nextConfig.staticPageGenerationTimeout,
+            waitUntil: ctx.waitUntil,
+            onClose: (cb)=>{
+                res.on('close', cb);
+            },
+            onAfterTaskError: undefined
+        },
+        sharedContext: {
+            buildId,
+            deploymentId
+        }
+    };
+    const nodeNextReq = new next_dist_server_base_http_node__WEBPACK_IMPORTED_MODULE_7__.NodeNextRequest(req);
+    const nodeNextRes = new next_dist_server_base_http_node__WEBPACK_IMPORTED_MODULE_7__.NodeNextResponse(res);
+    const nextReq = next_dist_server_web_spec_extension_adapters_next_request__WEBPACK_IMPORTED_MODULE_8__.NextRequestAdapter.fromNodeNextRequest(nodeNextReq, (0,next_dist_server_web_spec_extension_adapters_next_request__WEBPACK_IMPORTED_MODULE_8__.signalFromNodeResponse)(res));
+    const responseGenerator = async ({ previousCacheEntry })=>{
+        try {
+            if (!isMinimalMode && isOnDemandRevalidate && revalidateOnlyGenerated && !previousCacheEntry) {
+                res.statusCode = 404;
+                // on-demand revalidate always sets this header
+                res.setHeader('x-nextjs-cache', 'REVALIDATED');
+                res.end('This page could not be found');
+                return null;
+            }
+            const response = cacheKey === null ? await routeModule.handle(nextReq, context) : await routeModule.prerender(nextReq, context);
+            req.fetchMetrics = context.renderOpts.fetchMetrics;
+            let pendingWaitUntil = context.renderOpts.pendingWaitUntil;
+            // Attempt using provided waitUntil if available
+            // if it's not we fallback to sendResponse's handling
+            if (pendingWaitUntil) {
+                if (ctx.waitUntil) {
+                    ctx.waitUntil(pendingWaitUntil);
+                    pendingWaitUntil = undefined;
+                }
+            }
+            const cacheTags = context.renderOpts.collectedTags;
+            // If the request is for a static response, we can cache it so long
+            // as it's not edge.
+            if (isIsr) {
+                const blob = await response.blob();
+                // Copy the headers from the response.
+                const headers = (0,next_dist_server_web_utils__WEBPACK_IMPORTED_MODULE_12__.toNodeOutgoingHttpHeaders)(response.headers);
+                if (cacheTags) {
+                    headers[next_dist_lib_constants__WEBPACK_IMPORTED_MODULE_14__.NEXT_CACHE_TAGS_HEADER] = cacheTags;
+                }
+                if (!headers['content-type'] && blob.type) {
+                    headers['content-type'] = blob.type;
+                }
+                const revalidate = typeof context.renderOpts.collectedRevalidate === 'undefined' || context.renderOpts.collectedRevalidate >= next_dist_lib_constants__WEBPACK_IMPORTED_MODULE_14__.INFINITE_CACHE ? false : context.renderOpts.collectedRevalidate;
+                const expire = typeof context.renderOpts.collectedExpire === 'undefined' || context.renderOpts.collectedExpire >= next_dist_lib_constants__WEBPACK_IMPORTED_MODULE_14__.INFINITE_CACHE ? // route has a numeric `revalidate` but didn't declare an
+                // explicit `expire` (e.g. via `cacheLife`). This mirrors the
+                // build-time fallback in `build/index.ts` so cache entries
+                // and the response Cache-Control header agree on the route's
+                // effective expire. Routes that opt out of revalidation
+                // (`revalidate: false`) or that are dynamic (`revalidate: 0`)
+                // keep `expire: undefined`.
+                revalidate !== false && revalidate > 0 ? nextConfig.expireTime : undefined : context.renderOpts.collectedExpire;
+                // Create the cache entry for the response.
+                const cacheEntry = {
+                    value: {
+                        kind: next_dist_server_response_cache__WEBPACK_IMPORTED_MODULE_17__.CachedRouteKind.APP_ROUTE,
+                        status: response.status,
+                        body: Buffer.from(await blob.arrayBuffer()),
+                        headers
+                    },
+                    cacheControl: {
+                        revalidate,
+                        expire
+                    }
+                };
+                return cacheEntry;
+            } else {
+                // send response without caching if not ISR
+                await (0,next_dist_server_send_response__WEBPACK_IMPORTED_MODULE_11__/* .sendResponse */ .I)(nodeNextReq, nodeNextRes, response, pendingWaitUntil);
+                return null;
+            }
+        } catch (err) {
+            // if this is a background revalidate we need to report
+            // the request error here as it won't be bubbled
+            if (previousCacheEntry == null ? void 0 : previousCacheEntry.isStale) {
+                const silenceLog = false;
+                await routeModule.onRequestError(req, err, {
+                    routerKind: 'App Router',
+                    routePath: srcPage,
+                    routeType: 'route',
+                    revalidateReason: (0,next_dist_server_instrumentation_utils__WEBPACK_IMPORTED_MODULE_10__.getRevalidateReason)({
+                        isStaticGeneration: cacheKey !== null,
+                        isOnDemandRevalidate
+                    })
+                }, silenceLog, routerServerContext);
+            }
+            throw err;
+        }
+    };
+    const handleResponse = async (currentSpan, parentSpan)=>{
+        try {
+            var _cacheEntry_value;
+            const cacheEntry = await routeModule.handleResponse({
+                req,
+                nextConfig,
+                cacheKey,
+                routeKind: next_dist_server_route_kind__WEBPACK_IMPORTED_MODULE_1__.RouteKind.APP_ROUTE,
+                isFallback: false,
+                previewProps,
+                prerenderManifest,
+                isRoutePPREnabled: false,
+                isOnDemandRevalidate,
+                revalidateOnlyGenerated,
+                responseGenerator,
+                waitUntil: ctx.waitUntil,
+                isMinimalMode
+            });
+            if (cacheEntry !== null && 'error' in cacheEntry) {
+                throw cacheEntry.error;
+            }
+            // we don't create a cacheEntry for ISR
+            if (!isIsr) {
+                return;
+            }
+            if ((cacheEntry == null ? void 0 : (_cacheEntry_value = cacheEntry.value) == null ? void 0 : _cacheEntry_value.kind) !== next_dist_server_response_cache__WEBPACK_IMPORTED_MODULE_17__.CachedRouteKind.APP_ROUTE) {
+                var _cacheEntry_value1;
+                throw new Error(`Invariant: app-route received invalid cache entry ${cacheEntry == null ? void 0 : (_cacheEntry_value1 = cacheEntry.value) == null ? void 0 : _cacheEntry_value1.kind}`);
+            }
+            if (!isMinimalMode) {
+                res.setHeader('x-nextjs-cache', isOnDemandRevalidate ? 'REVALIDATED' : cacheEntry.isMiss ? 'MISS' : cacheEntry.isStale ? 'STALE' : 'HIT');
+            }
+            // Draft mode should never be cached
+            if (isDraftMode) {
+                res.setHeader('Cache-Control', 'private, no-cache, no-store, max-age=0, must-revalidate');
+            }
+            const headers = (0,next_dist_server_web_utils__WEBPACK_IMPORTED_MODULE_12__.fromNodeOutgoingHttpHeaders)(cacheEntry.value.headers);
+            if (!(isMinimalMode && isIsr)) {
+                headers.delete(next_dist_lib_constants__WEBPACK_IMPORTED_MODULE_14__.NEXT_CACHE_TAGS_HEADER);
+            }
+            // If cache control is already set on the response we don't
+            // override it to allow users to customize it via next.config
+            if (cacheEntry.cacheControl && !res.getHeader('Cache-Control') && !headers.get('Cache-Control')) {
+                headers.set('Cache-Control', (0,next_dist_server_lib_cache_control__WEBPACK_IMPORTED_MODULE_13__.getCacheControlHeader)(cacheEntry.cacheControl));
+            }
+            await (0,next_dist_server_send_response__WEBPACK_IMPORTED_MODULE_11__/* .sendResponse */ .I)(nodeNextReq, nodeNextRes, // @ts-expect-error - Argument of type 'Buffer<ArrayBufferLike>' is not assignable to parameter of type 'BodyInit | null | undefined'.
+            new Response(cacheEntry.value.body, {
+                headers,
+                status: cacheEntry.value.status || 200
+            }));
+            return;
+        } catch (err) {
+            if (!(err instanceof next_dist_shared_lib_no_fallback_error_external__WEBPACK_IMPORTED_MODULE_15__.NoFallbackError)) {
+                const silenceLog = false;
+                await routeModule.onRequestError(req, err, {
+                    routerKind: 'App Router',
+                    routePath: normalizedSrcPage,
+                    routeType: 'route',
+                    revalidateReason: (0,next_dist_server_instrumentation_utils__WEBPACK_IMPORTED_MODULE_10__.getRevalidateReason)({
+                        isStaticGeneration: cacheKey !== null,
+                        isOnDemandRevalidate
+                    })
+                }, silenceLog, routerServerContext);
+            }
+            // rethrow so that we can handle serving error page
+            // If this is during static generation, throw the error again.
+            if (isIsr) throw err;
+            // Otherwise, send a 500 response unless the original response has
+            // already committed. In that case, preserve its status code for
+            // telemetry while still recording the failure and terminating a response
+            // that the failed pipeline left open.
+            if (res.headersSent) {
+                if (currentSpan) {
+                    const error = err instanceof Error ? err : new Error('Unknown app route error');
+                    currentSpan.recordException(error);
+                    currentSpan.setStatus({
+                        code: next_dist_server_lib_trace_tracer__WEBPACK_IMPORTED_MODULE_4__.SpanStatusCode.ERROR,
+                        message: error.message
+                    });
+                    currentSpan.setAttribute('error.type', error.name);
+                }
+                if (!res.writableEnded && !res.destroyed) {
+                    res.end();
+                }
+            } else {
+                await (0,next_dist_server_send_response__WEBPACK_IMPORTED_MODULE_11__/* .sendResponse */ .I)(nodeNextReq, nodeNextRes, new Response(null, {
+                    status: 500
+                }));
+            }
+            return;
+        } finally{
+            ;
+            (()=>{
+                if (!currentSpan) {
+                    return;
+                }
+                let statusCode = res.statusCode;
+                currentSpan.setAttributes({
+                    'http.status_code': statusCode,
+                    'next.rsc': false
+                });
+                if (statusCode && statusCode >= 500) {
+                    // For 5xx status codes: SHOULD be set to 'Error' span status.
+                    // x-ref: https://opentelemetry.io/docs/specs/semconv/http/http-spans/#status
+                    currentSpan.setStatus({
+                        code: next_dist_server_lib_trace_tracer__WEBPACK_IMPORTED_MODULE_4__.SpanStatusCode.ERROR
+                    });
+                    // For span status 'Error', SHOULD set 'error.type' attribute.
+                    currentSpan.setAttribute('error.type', statusCode.toString());
+                }
+                const rootSpanAttributes = tracer.getRootSpanAttributes();
+                // We were unable to get attributes, probably OTEL is not enabled
+                if (!rootSpanAttributes) {
+                    return;
+                }
+                if (rootSpanAttributes.get('next.span_type') !== next_dist_server_lib_trace_constants__WEBPACK_IMPORTED_MODULE_9__.BaseServerSpan.handleRequest) {
+                    console.warn(`Unexpected root span type '${rootSpanAttributes.get('next.span_type')}'. Please report this Next.js issue https://github.com/vercel/next.js`);
+                    return;
+                }
+                const route = rootSpanAttributes.get('next.route') || normalizedSrcPage;
+                const name = `${method} ${route}`;
+                currentSpan.setAttributes({
+                    'next.route': route,
+                    'http.route': route,
+                    'next.span_name': name
+                });
+                currentSpan.updateName(name);
+                // Propagate http.route to the parent span if one exists (e.g.
+                // a platform-created HTTP span in adapter deployments).
+                if (parentSpan && parentSpan !== currentSpan) {
+                    parentSpan.setAttribute('http.route', route);
+                    parentSpan.updateName(name);
+                }
+            })();
+        }
+    };
+    // TODO: activeSpan code path is for when wrapped by
+    // next-server can be removed when this is no longer used
+    if (isWrappedByNextServer && activeSpan) {
+        await handleResponse(activeSpan, undefined);
+    } else {
+        let parentSpan = tracer.getActiveScopeSpan();
+        await tracer.withPropagatedContext(req.headers, ()=>tracer.trace(next_dist_server_lib_trace_constants__WEBPACK_IMPORTED_MODULE_9__.BaseServerSpan.handleRequest, {
+                spanName: `${method} ${srcPage}`,
+                kind: next_dist_server_lib_trace_tracer__WEBPACK_IMPORTED_MODULE_4__.SpanKind.SERVER,
+                attributes: {
+                    'http.method': method,
+                    'http.target': req.url
+                }
+            }, (span)=>handleResponse(span, parentSpan)), undefined, !isWrappedByNextServer);
+    }
+}
+
+//# sourceMappingURL=app-route.js.map
+
+
+/***/ }),
+
+/***/ 16698:
+/***/ ((module) => {
+
+module.exports = require("node:async_hooks");
+
+/***/ }),
+
+/***/ 19121:
+/***/ ((module) => {
+
+module.exports = require("next/dist/server/app-render/action-async-storage.external.js");
+
+/***/ }),
+
+/***/ 27910:
+/***/ ((module) => {
+
+module.exports = require("stream");
+
+/***/ }),
+
+/***/ 28354:
+/***/ ((module) => {
+
+module.exports = require("util");
+
+/***/ }),
+
+/***/ 29021:
+/***/ ((module) => {
+
+module.exports = require("fs");
+
+/***/ }),
+
+/***/ 29294:
+/***/ ((module) => {
+
+module.exports = require("next/dist/server/app-render/work-async-storage.external.js");
+
+/***/ }),
+
+/***/ 31421:
+/***/ ((module) => {
+
+module.exports = require("node:child_process");
+
+/***/ }),
+
+/***/ 33873:
+/***/ ((module) => {
+
+module.exports = require("path");
+
+/***/ }),
+
+/***/ 37067:
+/***/ ((module) => {
+
+module.exports = require("node:http");
+
+/***/ }),
+
+/***/ 38522:
+/***/ ((module) => {
+
+module.exports = require("node:zlib");
+
+/***/ }),
+
+/***/ 44708:
+/***/ ((module) => {
+
+module.exports = require("node:https");
+
+/***/ }),
+
+/***/ 44870:
+/***/ ((module) => {
+
+module.exports = require("next/dist/compiled/next-server/app-route.runtime.prod.js");
+
+/***/ }),
+
+/***/ 48161:
+/***/ ((module) => {
+
+module.exports = require("node:os");
+
+/***/ }),
+
+/***/ 51455:
+/***/ ((module) => {
+
+module.exports = require("node:fs/promises");
+
+/***/ }),
+
+/***/ 55511:
+/***/ ((module) => {
+
+module.exports = require("crypto");
+
+/***/ }),
+
+/***/ 55591:
+/***/ ((module) => {
+
+module.exports = require("https");
+
+/***/ }),
+
+/***/ 57075:
+/***/ ((module) => {
+
+module.exports = require("node:stream");
+
+/***/ }),
+
+/***/ 57975:
+/***/ ((module) => {
+
+module.exports = require("node:util");
+
+/***/ }),
+
+/***/ 63033:
+/***/ ((module) => {
+
+module.exports = require("next/dist/server/app-render/work-unit-async-storage.external.js");
+
+/***/ }),
+
+/***/ 63541:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   C: () => (/* binding */ getThreadActivity)
+/* harmony export */ });
+/* harmony import */ var _lib_agents_run_registry__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(68564);
+/* harmony import */ var _lib_agents_run_queue__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(3944);
+/* harmony import */ var _lib_agents_thread_compaction_state__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(87313);
+
+
+
+function getThreadActivity(threadId) {
+    const active = (0,_lib_agents_run_registry__WEBPACK_IMPORTED_MODULE_0__/* .getRun */ .Mh)(threadId);
+    const run = active && active.status === "running" ? {
+        phase: active.phase,
+        label: active.phase_label,
+        started_at: active.started_at,
+        agent_id: active.agent_id
+    } : null;
+    const queue_depth = (0,_lib_agents_run_queue__WEBPACK_IMPORTED_MODULE_1__.getQueueDepth)(threadId);
+    const attempt = (0,_lib_agents_thread_compaction_state__WEBPACK_IMPORTED_MODULE_2__/* .currentCompaction */ .$I)(threadId);
+    const compaction = attempt ? {
+        kind: attempt.kind,
+        boundary_seq: attempt.boundarySeq,
+        started_at: attempt.startedAt,
+        deadline_at: attempt.deadlineAt
+    } : null;
+    return {
+        run,
+        queue_depth,
+        compaction,
+        busy: run !== null || queue_depth > 0 || compaction !== null
+    };
+}
+
+
+/***/ }),
+
+/***/ 68564:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   AD: () => (/* binding */ startRun),
+/* harmony export */   B1: () => (/* binding */ subscribe),
+/* harmony export */   Cs: () => (/* binding */ waitForRun),
+/* harmony export */   ES: () => (/* binding */ abortAllRuns),
+/* harmony export */   JH: () => (/* binding */ finishRun),
+/* harmony export */   KD: () => (/* binding */ abortRun),
+/* harmony export */   Mh: () => (/* binding */ getRun),
+/* harmony export */   QK: () => (/* binding */ drainSteering),
+/* harmony export */   mq: () => (/* binding */ broadcast),
+/* harmony export */   mx: () => (/* binding */ pushSteering)
+/* harmony export */ });
+/* unused harmony export waitForRunsToSettle */
+/* harmony import */ var _lib_env_config__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(67500);
+/* harmony import */ var _lib_utils_global_state__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(15559);
+
+
+// Read once at module init. JARELA_RUN_BUFFER_SIZE / JARELA_RUN_REGISTRY_TTL_MS
+// override the defaults.
+const MAX_BUFFERED = (0,_lib_env_config__WEBPACK_IMPORTED_MODULE_0__/* .getConfig */ .z)().runBufferSize;
+const RECENT_TTL_MS = (0,_lib_env_config__WEBPACK_IMPORTED_MODULE_0__/* .getConfig */ .z)().runRegistryTtlMs;
+// Idle (no-progress) ceiling and wall-clock ceiling: read fresh per-run
+// from getConfig() so non-restart-required env reloads take effect.
+function runIdleMs() {
+    return (0,_lib_env_config__WEBPACK_IMPORTED_MODULE_0__/* .getConfig */ .z)().runIdleMs;
+}
+function runMaxMs() {
+    return (0,_lib_env_config__WEBPACK_IMPORTED_MODULE_0__/* .getConfig */ .z)().runMaxMs;
+}
+const registryState = (0,_lib_utils_global_state__WEBPACK_IMPORTED_MODULE_1__/* .getOrCreateGlobal */ .X)("__jarela_active_run_registry", ()=>({
+        runs: new Map(),
+        waiters: new Map()
+    }));
+const runs = registryState.runs;
+// Cold-attach waiters: subscribers that opened a GET /run before the
+// server-side run actually called startRun (typical for triggers /
+// scheduler / watcher, which submit through `after()` + the per-thread
+// queue, so there's a real delay between the user clicking "Run now"
+// and the registry entry appearing). Resolved by `startRun` below.
+const waiters = registryState.waiters;
+/** Wait up to `timeoutMs` for a run to be registered on `thread_id`.
+ *  Resolves immediately with the current run if one is already active,
+ *  with the new run when `startRun` fires inside the window, or with
+ *  `null` on timeout. `timeoutMs <= 0` short-circuits to the current
+ *  state without waiting. Caller is responsible for closing the SSE
+ *  stream when this resolves null. */ function waitForRun(thread_id, timeoutMs) {
+    const existing = runs.get(thread_id);
+    if (existing) return Promise.resolve(existing);
+    if (timeoutMs <= 0) return Promise.resolve(null);
+    return new Promise((resolve)=>{
+        let set = waiters.get(thread_id);
+        if (!set) {
+            set = new Set();
+            waiters.set(thread_id, set);
+        }
+        const fn = (run)=>{
+            clearTimeout(timer);
+            resolve(run);
+        };
+        set.add(fn);
+        const timer = setTimeout(()=>{
+            const cur = waiters.get(thread_id);
+            cur?.delete(fn);
+            if (cur && cur.size === 0) waiters.delete(thread_id);
+            resolve(null);
+        }, timeoutMs);
+        timer.unref?.();
+    });
+}
+function startRun(thread_id, agent_id) {
+    // If a stale completed run exists, drop it before starting a new one.
+    const existing = runs.get(thread_id);
+    if (existing && existing.status === "running") {
+        throw new Error(`A run is already active for thread ${thread_id}`);
+    }
+    const now = Date.now();
+    const run = {
+        thread_id,
+        agent_id,
+        started_at: now,
+        finished_at: null,
+        status: "running",
+        events: [],
+        subscribers: new Set(),
+        final_text: "",
+        abort: new AbortController(),
+        last_chunk_at: now,
+        inflight_tools: new Set(),
+        tool_started_at: new Map(),
+        tool_time_ms_done: 0,
+        steering: [],
+        phase: "starting",
+        phase_label: "Starting…"
+    };
+    runs.set(thread_id, run);
+    // Wake any GET subscribers that attached before the run was registered.
+    const pending = waiters.get(thread_id);
+    if (pending) {
+        waiters.delete(thread_id);
+        for (const fn of pending){
+            try {
+                fn(run);
+            } catch  {}
+        }
+    }
+    scheduleIdleWatchdog(run);
+    scheduleMaxWatchdog(run);
+    return run;
+}
+// Synthesise a typed error chunk for the watchdog termination paths and
+// fan it out to subscribers BEFORE flipping `status` to "error". The order
+// matters: `broadcast()`'s status guard drops any chunk delivered after
+// `finishRun()` has run, so calling finishRun first would silently swallow
+// the error and the client's EventSource would just see the connection
+// close with no terminal event — bubble keeps spinning, no toast. Doing
+// it the other way around lets the client receive a real error event,
+// render a "Run timed out" toast, and (if the consumer wires it up)
+// trigger an auto-retry path. Followed by `done` so the consumer's
+// for-await loop can break cleanly without waiting for an EOF.
+function emitWatchdogTermination(run, code, message) {
+    if (run.status !== "running") return;
+    // Direct registry mutation so the broadcast goes through the regular
+    // path (subscribers + buffer + seq stamp) without re-entering any of
+    // the watchdog scheduling. Mirrors broadcast() but bypasses the
+    // status check we'd otherwise be racing against.
+    run.last_chunk_at = Date.now();
+    const errChunk = {
+        type: "error",
+        data: {
+            message,
+            code
+        }
+    };
+    if (run.events.length < MAX_BUFFERED) run.events.push(errChunk);
+    for (const fn of run.subscribers){
+        try {
+            fn(errChunk);
+        } catch  {}
+    }
+    // Pair with a synthetic `done` so the client's consume() loop breaks
+    // on a terminal event rather than waiting for the EventSource to close.
+    const doneChunk = {
+        type: "done",
+        data: {}
+    };
+    if (run.events.length < MAX_BUFFERED) run.events.push(doneChunk);
+    for (const fn of run.subscribers){
+        try {
+            fn(doneChunk);
+        } catch  {}
+    }
+}
+// Self-rearming idle watchdog. Fires when no chunk has arrived for
+// `idleMs`; otherwise reschedules itself for `(last_chunk_at + idleMs) -
+// now`. We never carry a handle on the run — the closure just bails if
+// the run is no longer the registry's entry or no longer running.
+function scheduleIdleWatchdog(run) {
+    const idleMs = runIdleMs();
+    const fireIn = Math.max(0, run.last_chunk_at + idleMs - Date.now());
+    setTimeout(()=>{
+        const cur = runs.get(run.thread_id);
+        if (cur !== run) return;
+        if (run.status !== "running") return;
+        const idle = Date.now() - run.last_chunk_at;
+        if (idle < idleMs) {
+            scheduleIdleWatchdog(run);
+            return;
+        }
+        if (run.inflight_tools.size > 0) {
+            // Tool execution in progress — silence here is the tool working,
+            // not a wedged provider stream. Skip the kill, re-check in idleMs.
+            // The tool_result will bump last_chunk_at when it lands.
+            setTimeout(()=>scheduleIdleWatchdog(run), idleMs).unref?.();
+            return;
+        }
+        console.warn(`[run-registry] idle watchdog: force-finishing stalled run for thread ${run.thread_id} after ${idle}ms of no progress`);
+        emitWatchdogTermination(run, "run_idle_timeout", `Run timed out — no progress for ${Math.round(idle / 1000)}s. The provider stream went silent before the agent finished. Try again, or split the request into smaller steps.`);
+        try {
+            run.abort.abort("run_idle_timeout");
+        } catch  {}
+        finishRun(run, "error");
+    }, fireIn).unref?.();
+}
+// Wall-clock elapsed minus time spent inside tool calls (both completed and
+// currently in flight). The wall-clock watchdog uses this so a 5-minute
+// shell exec or a slow MCP roundtrip doesn't burn the agent's budget;
+// tools enforce their own timeouts. See ActiveRun.tool_started_at for the
+// rationale.
+function effectiveElapsedMs(run, now) {
+    let inflightToolMs = 0;
+    for (const startedAt of run.tool_started_at.values()){
+        inflightToolMs += Math.max(0, now - startedAt);
+    }
+    return Math.max(0, now - run.started_at - run.tool_time_ms_done - inflightToolMs);
+}
+function scheduleMaxWatchdog(run) {
+    const max = runMaxMs();
+    const now = Date.now();
+    const fireIn = Math.max(0, max - effectiveElapsedMs(run, now));
+    setTimeout(()=>{
+        const cur = runs.get(run.thread_id);
+        if (cur !== run) return;
+        if (run.status !== "running") return;
+        const elapsed = effectiveElapsedMs(run, Date.now());
+        if (elapsed < max) {
+            // Tool time pushed the effective elapsed back below the ceiling —
+            // re-arm for the remaining budget. Without this, a tool that runs
+            // for longer than `max` between firing and resolving would let
+            // the next setTimeout overshoot.
+            scheduleMaxWatchdog(run);
+            return;
+        }
+        console.warn(`[run-registry] wall-clock watchdog: force-finishing run for thread ${run.thread_id} after ${elapsed}ms of agent time (excluding tool execution)`);
+        emitWatchdogTermination(run, "run_max_timeout", `Run exceeded the wall-clock limit (${Math.round(max / 1000)}s of agent time, excluding tool execution). The agent was force-stopped. Try a smaller scope or raise JARELA_RUN_MAX_MS if this is expected.`);
+        try {
+            run.abort.abort("run_watchdog_timeout");
+        } catch  {}
+        finishRun(run, "error");
+    }, fireIn).unref?.();
+}
+// Mirrors the labels hooks/useSSE.ts derives from the same chunks.
+function trackPhase(run, chunk) {
+    const data = chunk.data ?? {};
+    const set = (phase, label)=>{
+        run.phase = phase;
+        run.phase_label = label;
+    };
+    if (chunk.type === "status") {
+        const phase = typeof data.phase === "string" && data.phase ? data.phase : run.phase;
+        const label = typeof data.label === "string" && data.label.trim() ? data.label : "Thinking…";
+        set(phase, label);
+    } else if (chunk.type === "text_delta") {
+        set("responding", "Responding…");
+    } else if (chunk.type === "thinking_delta") {
+        if (run.inflight_tools.size === 0) set("thinking", "Thinking…");
+    } else if (chunk.type === "tool_call") {
+        const name = typeof data.name === "string" && data.name ? data.name : "tool";
+        set("tool", `Using ${name}…`);
+    } else if (chunk.type === "tool_result") {
+        const remaining = typeof data.id === "string" ? [
+            ...run.inflight_tools
+        ].filter((id)=>id !== data.id) : [
+            ...run.inflight_tools
+        ];
+        if (remaining.length === 0) set("thinking", "Thinking…");
+    }
+}
+function broadcast(run, chunk) {
+    // Identity-check: a superseded run must not smear trailing chunks onto
+    // the replacement entry in the registry.
+    if (runs.get(run.thread_id) !== run) return;
+    run.last_chunk_at = Date.now();
+    // Heartbeats exist solely to reset the idle watchdog when the provider
+    // is producing chunks that don't surface downstream (most commonly
+    // partial tool-call args while the model streams a large file_write
+    // body). The last_chunk_at bump above is the entire payload — don't
+    // buffer, don't fan out to subscribers, or the SSE wire would carry
+    // meaningless tick events.
+    if (chunk.type === "heartbeat") return;
+    trackPhase(run, chunk);
+    if (chunk.type === "text_delta") {
+        run.final_text += chunk.data.delta ?? "";
+    } else if (chunk.type === "reset_text") {
+        // Output-validator retry (ADR-0037) discarding a flagged completed
+        // reply — see StreamChunk in base.ts.
+        run.final_text = "";
+    } else if (chunk.type === "tool_call") {
+        const id = chunk.data.id;
+        if (id) {
+            run.inflight_tools.add(id);
+            run.tool_started_at.set(id, Date.now());
+        }
+    } else if (chunk.type === "tool_result") {
+        const id = chunk.data.id;
+        if (id) {
+            run.inflight_tools.delete(id);
+            const startedAt = run.tool_started_at.get(id);
+            if (startedAt !== undefined) {
+                run.tool_time_ms_done += Math.max(0, Date.now() - startedAt);
+                run.tool_started_at.delete(id);
+                // The tool just gave the agent its budget back; re-arm the
+                // wall-clock watchdog against the new effective elapsed.
+                scheduleMaxWatchdog(run);
+            }
+        }
+    }
+    if (run.events.length < MAX_BUFFERED) {
+        run.events.push(chunk);
+    }
+    for (const fn of run.subscribers){
+        try {
+            fn(chunk);
+        } catch  {}
+    }
+}
+function finishRun(run, status) {
+    // Identity-check: a stale run finishing late must not flip the
+    // replacement's status or evict it from the registry.
+    if (runs.get(run.thread_id) !== run) return;
+    run.status = status;
+    run.finished_at = Date.now();
+    // Drop subscribers — late attachers should NOT keep getting events on a
+    // dead run. They'll get the buffered events on subscribe and that's it.
+    run.subscribers.clear();
+    // Auto-evict after TTL so memory doesn't grow with every conversation.
+    setTimeout(()=>{
+        const cur = runs.get(run.thread_id);
+        if (cur === run) runs.delete(run.thread_id);
+    }, RECENT_TTL_MS).unref?.();
+}
+function getRun(thread_id) {
+    return runs.get(thread_id) ?? null;
+}
+// Signal the agent stream to cancel. The stream loop in the route is wired
+// to listen on the AbortController and exit early, emitting an error chunk
+// the client (and the queue-drain hook) can react to. Idempotent.
+function abortRun(thread_id, reason = "user_interrupted") {
+    const run = runs.get(thread_id);
+    if (!run || run.status !== "running") return false;
+    if (!run.abort.signal.aborted) {
+        try {
+            run.abort.abort(reason);
+        } catch  {}
+    }
+    return true;
+}
+// Queue a user message typed while `thread_id` is streaming (ADR-0080).
+// Returns false when there is nothing to steer, so the caller can fall back
+// to starting a fresh turn.
+function pushSteering(thread_id, text) {
+    const run = runs.get(thread_id);
+    if (!run || run.status !== "running" || run.abort.signal.aborted) return false;
+    const trimmed = text.trim();
+    if (!trimmed) return false;
+    run.steering.push(trimmed);
+    return true;
+}
+// Take everything queued so far, in arrival order. Deliberately not merged
+// into a summary — collapsing several messages loses the user's intent.
+function drainSteering(thread_id) {
+    const run = runs.get(thread_id);
+    if (!run || run.steering.length === 0) return [];
+    return run.steering.splice(0, run.steering.length);
+}
+// Abort every currently-running run. Used by the graceful-shutdown path so
+// LangGraph stream loops bail out instead of continuing past process exit.
+// Returns the number of runs that were signalled.
+function abortAllRuns(reason = "server_shutdown") {
+    let count = 0;
+    for (const run of runs.values()){
+        if (run.status !== "running") continue;
+        if (run.abort.signal.aborted) continue;
+        try {
+            run.abort.abort(reason);
+            count++;
+        } catch  {}
+    }
+    return count;
+}
+// Poll until every run has transitioned out of "running" (or until the
+// caller-supplied deadline elapses). Used during graceful shutdown after
+// `abortAllRuns()` so the stream `finally` blocks have a chance to flush
+// the trailing error chunk and call `finishRun()`. Resolves to the count
+// of runs still stuck in "running" when the deadline hit (0 = clean).
+async function waitForRunsToSettle(timeoutMs) {
+    const deadline = Date.now() + Math.max(0, timeoutMs);
+    while(Date.now() < deadline){
+        let stillRunning = 0;
+        for (const run of runs.values())if (run.status === "running") stillRunning++;
+        if (stillRunning === 0) return 0;
+        await new Promise((resolve)=>setTimeout(resolve, 50));
+    }
+    let stillRunning = 0;
+    for (const run of runs.values())if (run.status === "running") stillRunning++;
+    return stillRunning;
+}
+// Replays buffered events synchronously, then subscribes for live ones.
+// Returns an unsubscribe fn. Caller is responsible for calling it.
+function subscribe(thread_id, onEvent) {
+    const run = runs.get(thread_id);
+    if (!run) return {
+        run: null,
+        unsubscribe: ()=>{}
+    };
+    // Replay buffered events first (so the new subscriber catches up).
+    for (const ev of run.events){
+        try {
+            onEvent(ev);
+        } catch  {}
+    }
+    if (run.status !== "running") {
+        return {
+            run,
+            unsubscribe: ()=>{}
+        };
+    }
+    run.subscribers.add(onEvent);
+    return {
+        run,
+        unsubscribe: ()=>{
+            run.subscribers.delete(onEvent);
+        }
+    };
+}
+
+
+/***/ }),
+
+/***/ 73024:
+/***/ ((module) => {
+
+module.exports = require("node:fs");
+
+/***/ }),
+
+/***/ 75919:
+/***/ ((module) => {
+
+module.exports = require("node:worker_threads");
+
+/***/ }),
+
+/***/ 76760:
+/***/ ((module) => {
+
+module.exports = require("node:path");
+
+/***/ }),
+
+/***/ 77030:
+/***/ ((module) => {
+
+module.exports = require("node:net");
+
+/***/ }),
+
+/***/ 77598:
+/***/ ((module) => {
+
+module.exports = require("node:crypto");
+
+/***/ }),
+
+/***/ 79428:
+/***/ ((module) => {
+
+module.exports = require("buffer");
+
+/***/ }),
+
+/***/ 80099:
+/***/ ((module) => {
+
+module.exports = require("node:sqlite");
+
+/***/ }),
+
+/***/ 80481:
+/***/ ((module) => {
+
+module.exports = require("node:readline");
+
+/***/ }),
+
+/***/ 81630:
+/***/ ((module) => {
+
+module.exports = require("http");
+
+/***/ }),
+
+/***/ 86439:
+/***/ ((module) => {
+
+module.exports = require("next/dist/shared/lib/no-fallback-error.external");
+
+/***/ }),
+
+/***/ 87313:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   $I: () => (/* binding */ currentCompaction),
+/* harmony export */   D0: () => (/* binding */ isCompactionRunning),
+/* harmony export */   Dc: () => (/* binding */ getCompactionAttempt),
+/* harmony export */   PL: () => (/* binding */ runTrackedCompaction),
+/* harmony export */   nQ: () => (/* binding */ CompactionTimeoutError)
+/* harmony export */ });
+/* unused harmony export __resetCompactionAttemptsForTests */
+/* harmony import */ var _lib_env_config__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(67500);
+/* harmony import */ var _lib_utils_global_state__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(15559);
+
+
+class CompactionTimeoutError extends Error {
+    constructor(threadId, kind, timeoutMs){
+        super(`${kind} compaction for thread ${threadId} timed out after ${timeoutMs} ms`);
+        this.name = "CompactionTimeoutError";
+    }
+}
+const attempts = (0,_lib_utils_global_state__WEBPACK_IMPORTED_MODULE_1__/* .getOrCreateGlobal */ .X)("__jarela_thread_compaction_attempts", ()=>new Map());
+function slotFor(threadId) {
+    let slot = attempts.get(threadId);
+    if (!slot) {
+        slot = new Map();
+        attempts.set(threadId, slot);
+    }
+    return slot;
+}
+function release(attempt) {
+    const slot = attempts.get(attempt.threadId);
+    if (slot?.get(attempt.kind) !== attempt) return;
+    slot.delete(attempt.kind);
+    if (slot.size === 0) attempts.delete(attempt.threadId);
+}
+function getCompactionAttempt(threadId, kind) {
+    return attempts.get(threadId)?.get(kind) ?? null;
+}
+function isCompactionRunning(threadId, kind) {
+    const slot = attempts.get(threadId);
+    if (!slot) return false;
+    return kind ? slot.has(kind) : slot.size > 0;
+}
+const KIND_PRIORITY = [
+    "manual",
+    "auto",
+    "refresh"
+];
+/** The most significant compaction running on the thread, if any. */ function currentCompaction(threadId) {
+    const slot = attempts.get(threadId);
+    if (!slot) return null;
+    for (const kind of KIND_PRIORITY){
+        const attempt = slot.get(kind);
+        if (attempt) return attempt;
+    }
+    return null;
+}
+/**
+ * Register a compaction on the thread synchronously, run it, and release it
+ * when it settles or its deadline passes. On timeout the attempt stops being
+ * current — pass it to compactThreadWarmContext so a late result is dropped
+ * instead of committed — and the promise rejects with CompactionTimeoutError.
+ * A newer attempt of the same kind replaces (and invalidates) an older one.
+ */ function runTrackedCompaction(threadId, kind, boundarySeq, run, timeoutMs = (0,_lib_env_config__WEBPACK_IMPORTED_MODULE_0__/* .getConfig */ .z)().compactionTimeoutMs) {
+    const startedAt = Date.now();
+    let current = true;
+    const attempt = {
+        threadId,
+        kind,
+        boundarySeq,
+        startedAt,
+        deadlineAt: startedAt + timeoutMs,
+        isCurrent: ()=>current && attempts.get(threadId)?.get(kind) === attempt
+    };
+    slotFor(threadId).set(kind, attempt);
+    let timer = null;
+    const deadline = new Promise((_, reject)=>{
+        timer = setTimeout(()=>{
+            current = false;
+            release(attempt);
+            reject(new CompactionTimeoutError(threadId, kind, timeoutMs));
+        }, timeoutMs);
+        timer.unref?.();
+    });
+    let work;
+    try {
+        work = run(attempt);
+    } catch (err) {
+        work = Promise.reject(err);
+    }
+    return Promise.race([
+        work,
+        deadline
+    ]).finally(()=>{
+        if (timer) clearTimeout(timer);
+        current = false;
+        release(attempt);
+    });
+}
+function __resetCompactionAttemptsForTests() {
+    attempts.clear();
+}
+
+
+/***/ }),
+
+/***/ 94735:
+/***/ ((module) => {
+
+module.exports = require("events");
+
+/***/ }),
+
+/***/ 99253:
+/***/ ((module) => {
+
+module.exports = import("@huggingface/transformers");;
+
+/***/ })
+
+};
+;
+
+// load runtime
+var __webpack_require__ = require("../../../../../../webpack-runtime.js");
+__webpack_require__.C(exports);
+var __webpack_exec__ = (moduleId) => (__webpack_require__(__webpack_require__.s = moduleId))
+var __webpack_exports__ = __webpack_require__.X(0, [2970,7377,1813,7981,4992,46,3042], () => (__webpack_exec__(11075)));
+module.exports = __webpack_exports__;
+
+})();
+//# sourceMappingURL=route.js.map