@lobu/cli 7.1.0 → 7.2.0

package/dist/server.bundle.mjs

@@ -782,7 +782,7 @@ function createLogger(serviceName) {
       format: USE_JSON_FORMAT ? jsonFormat : humanFormat
     })
   ];
-  const logger98 = winston.createLogger({
+  const logger100 = winston.createLogger({
     level,
     format: winston.format.combine(
       winston.format.timestamp({ format: "YYYY-MM-DD HH:mm:ss" }),
@@ -796,12 +796,12 @@ function createLogger(serviceName) {
     if (isProduction || process.env.SENTRY_DSN) {
       try {
         const transport = new SentryTransport();
-        logger98.add(transport);
+        logger100.add(transport);
       } catch {
       }
     }
   });
-  return logger98;
+  return logger100;
 }
 var USE_WINSTON_LOGGER, USE_JSON_FORMAT, SentryTransport;
 var init_logger2 = __esm({
@@ -955,6 +955,7 @@ var init_capabilities = __esm({
       "browser.scripting",
       "browser.history",
       "browser.bookmarks",
+      "browser.downloads",
       "browser.debugger"
       // browser.cookies intentionally absent in v1 — high-trust, not approved
     ];
@@ -1808,7 +1809,8 @@ function generateWorkerToken(userId, conversationId, deploymentName, options) {
     platform: options.platform,
     sessionKey: options.sessionKey,
     traceId: options.traceId,
-    jti: randomUUID()
+    jti: randomUUID(),
+    runId: options.runId
   };
   return encrypt(JSON.stringify(payload));
 }
@@ -1832,6 +1834,12 @@ function verifyWorkerToken(token) {
       );
       return null;
     }
+    if (data.runId !== void 0) {
+      if (typeof data.runId !== "number" || !Number.isInteger(data.runId) || data.runId <= 0) {
+        logger10.error("Worker token rejected: runId must be a positive integer");
+        return null;
+      }
+    }
     const ttl = parsePositiveIntEnv("WORKER_TOKEN_TTL_MS", 2 * 60 * 60 * 1e3);
     const skewMs = parsePositiveIntEnv(
       "WORKER_TOKEN_CLOCK_SKEW_MS",
@@ -5752,12 +5760,32 @@ function sessionMatchesMetadataOwner(session, ownerPlatform, ownerUserId) {
   }
   return ownerPlatform === session.platform || session.platform === "external";
 }
+async function resolveAuthorizedOrgId(store, agentId, ownerPlatform, ownerUserId) {
+  if (!store || !ownerPlatform || !ownerUserId) return void 0;
+  const orgs = await store.findAgentOrganizations(
+    ownerPlatform,
+    ownerUserId,
+    agentId
+  );
+  if (orgs.length !== 1) return void 0;
+  return orgs[0];
+}
 async function verifyOwnedAgentAccess(session, agentId, config) {
   if (session.isAdmin) {
     return { authorized: true };
   }
   if (session.agentId) {
-    return { authorized: session.agentId === agentId };
+    if (session.agentId !== agentId) {
+      return { authorized: false };
+    }
+    const lookupUserId2 = resolveSettingsLookupUserId(session);
+    const organizationId2 = await resolveAuthorizedOrgId(
+      config.userAgentsStore,
+      agentId,
+      session.platform,
+      lookupUserId2 || void 0
+    );
+    return { authorized: true, organizationId: organizationId2 };
   }
   const lookupUserId = resolveSettingsLookupUserId(session);
   if (config.userAgentsStore) {
@@ -5767,10 +5795,17 @@ async function verifyOwnedAgentAccess(session, agentId, config) {
       agentId
     );
     if (owns) {
+      const organizationId2 = await resolveAuthorizedOrgId(
+        config.userAgentsStore,
+        agentId,
+        session.platform,
+        lookupUserId
+      );
       return {
         authorized: true,
         ownerPlatform: session.platform,
-        ownerUserId: lookupUserId
+        ownerUserId: lookupUserId,
+        organizationId: organizationId2
       };
     }
   }
@@ -5789,10 +5824,17 @@ async function verifyOwnedAgentAccess(session, agentId, config) {
     config.userAgentsStore.addAgent(session.platform, lookupUserId, agentId).catch(() => {
     });
   }
+  const organizationId = metadata.organizationId ?? await resolveAuthorizedOrgId(
+    config.userAgentsStore,
+    agentId,
+    metadata.owner.platform,
+    metadata.owner.userId
+  );
   return {
     authorized: true,
     ownerPlatform: metadata.owner.platform,
-    ownerUserId: metadata.owner.userId
+    ownerUserId: metadata.owner.userId,
+    organizationId
   };
 }
 function createTokenVerifier(config) {
@@ -5802,6 +5844,12 @@ function createTokenVerifier(config) {
     return result.authorized ? payload : null;
   };
 }
+function createOwnershipResolver(config) {
+  return async (payload, agentId) => {
+    if (!payload) return { authorized: false };
+    return verifyOwnedAgentAccess(payload, agentId, config);
+  };
+}
 var init_agent_ownership = __esm({
   "src/gateway/routes/shared/agent-ownership.ts"() {
     "use strict";
@@ -6196,41 +6244,46 @@ function createAgentApi(config) {
       if (requestSignal?.aborted) {
         return;
       }
-      sseManager.addConnection(sseKey, stream2);
-      await stream2.writeSSE({
-        event: "connected",
-        data: JSON.stringify({
-          agentId: session.agentId || sessionKey3,
-          timestamp: Date.now()
-        })
-      });
-      for (const entry of sseManager.getRecentEvents(sseKey)) {
-        await stream2.writeSSE({
-          event: entry.event,
-          data: JSON.stringify(entry.data)
-        });
-      }
-      const heartbeatInterval = setInterval(async () => {
-        try {
-          await stream2.writeSSE({
-            event: "ping",
-            data: JSON.stringify({ timestamp: Date.now() })
-          });
-        } catch {
-          clearInterval(heartbeatInterval);
-        }
-      }, 3e4);
+      let heartbeatInterval;
+      let connectionAdded = false;
       let cleanedUp = false;
       const cleanup = () => {
         if (cleanedUp) return;
         cleanedUp = true;
-        clearInterval(heartbeatInterval);
-        sseManager.removeConnection(sseKey, stream2);
+        if (heartbeatInterval) clearInterval(heartbeatInterval);
+        if (connectionAdded) {
+          sseManager.removeConnection(sseKey, stream2);
+        }
         logger24.info(`SSE connection closed for session ${sseKey}`);
       };
       stream2.onAbort(cleanup);
       const detachAbortBridge = bindRequestAbortToStream(requestSignal, stream2);
+      sseManager.addConnection(sseKey, stream2);
+      connectionAdded = true;
       try {
+        await stream2.writeSSE({
+          event: "connected",
+          data: JSON.stringify({
+            agentId: session.agentId || sessionKey3,
+            timestamp: Date.now()
+          })
+        });
+        for (const entry of sseManager.getRecentEvents(sseKey)) {
+          await stream2.writeSSE({
+            event: entry.event,
+            data: JSON.stringify(entry.data)
+          });
+        }
+        heartbeatInterval = setInterval(async () => {
+          try {
+            await stream2.writeSSE({
+              event: "ping",
+              data: JSON.stringify({ timestamp: Date.now() })
+            });
+          } catch {
+            if (heartbeatInterval) clearInterval(heartbeatInterval);
+          }
+        }, 3e4);
         while (!stream2.aborted && !stream2.closed) {
           await stream2.sleep(1e3);
         }
@@ -7129,6 +7182,20 @@ var init_agent_config = __esm({
 import { readdir, readFile, stat } from "node:fs/promises";
 import { join, resolve } from "node:path";
 import { Hono as Hono7 } from "hono";
+async function readLatestSnapshotJsonl(agentId, organizationId) {
+  if (!organizationId) return null;
+  const sql = getDb();
+  const snapshotRows = await sql`
+    SELECT snapshot_jsonl
+    FROM public.agent_transcript_snapshot
+    WHERE organization_id = ${organizationId}
+      AND agent_id = ${agentId}
+      AND terminal_status = 'completed'
+    ORDER BY run_id DESC
+    LIMIT 1
+  `;
+  return snapshotRows[0]?.snapshot_jsonl ?? null;
+}
 function isSafeAgentId(id) {
   return SAFE_AGENT_ID.test(id);
 }
@@ -7225,17 +7292,23 @@ function entryToMessage(entry) {
   }
   return null;
 }
-async function readSessionMessages(agentId, cursorParam, limit) {
-  const sessionPath = await findSessionFile(agentId);
-  if (!sessionPath) {
-    return {
-      messages: [],
-      nextCursor: null,
-      hasMore: false,
-      sessionId: "none"
-    };
+async function readSessionMessages(agentId, cursorParam, limit, organizationId) {
+  let content = null;
+  if (process.env.LOBU_SESSION_STORE !== "file") {
+    content = await readLatestSnapshotJsonl(agentId, organizationId);
+  }
+  if (content === null) {
+    const sessionPath = await findSessionFile(agentId);
+    if (!sessionPath) {
+      return {
+        messages: [],
+        nextCursor: null,
+        hasMore: false,
+        sessionId: "none"
+      };
+    }
+    content = await readFile(sessionPath, "utf-8");
   }
-  const content = await readFile(sessionPath, "utf-8");
   const { entries, sessionId } = parseSessionEntries(content);
   const allMessages = [];
   for (const entry of entries) {
@@ -7257,19 +7330,25 @@ async function readSessionMessages(agentId, cursorParam, limit) {
     sessionId: sessionId || "unknown"
   };
 }
-async function readSessionStats(agentId) {
-  const sessionPath = await findSessionFile(agentId);
-  if (!sessionPath) {
-    return {
-      sessionId: "none",
-      messageCount: 0,
-      userMessages: 0,
-      assistantMessages: 0,
-      totalInputTokens: 0,
-      totalOutputTokens: 0
-    };
+async function readSessionStats(agentId, organizationId) {
+  let content = null;
+  if (process.env.LOBU_SESSION_STORE !== "file") {
+    content = await readLatestSnapshotJsonl(agentId, organizationId);
+  }
+  if (content === null) {
+    const sessionPath = await findSessionFile(agentId);
+    if (!sessionPath) {
+      return {
+        sessionId: "none",
+        messageCount: 0,
+        userMessages: 0,
+        assistantMessages: 0,
+        totalInputTokens: 0,
+        totalOutputTokens: 0
+      };
+    }
+    content = await readFile(sessionPath, "utf-8");
   }
-  const content = await readFile(sessionPath, "utf-8");
   const { entries, sessionId } = parseSessionEntries(content);
   let messageCount = 0;
   let userMessages = 0;
@@ -7305,17 +7384,18 @@ async function readSessionStats(agentId) {
 function createAgentHistoryRoutes(deps) {
   const app3 = new Hono7();
   const { connectionManager } = deps;
-  const verifyToken = createTokenVerifier({
+  const resolveOwnership = createOwnershipResolver({
     userAgentsStore: deps.userAgentsStore,
     agentMetadataStore: deps.agentConfigStore
   });
-  async function getAuthorizedAgentId(c) {
+  async function getAuthorizedAgentScope(c) {
     const session = await verifySettingsSession(c);
     if (!session) return null;
     const agentId = c.req.param("agentId") || session.agentId || null;
     if (!agentId || !isSafeAgentId(agentId)) return null;
-    const verified = await verifyToken(session, agentId);
-    return verified ? agentId : null;
+    const result = await resolveOwnership(session, agentId);
+    if (!result.authorized) return null;
+    return { agentId, organizationId: result.organizationId };
   }
   async function resolveActiveAgent(agentId) {
     if (connectionManager.getDeploymentsForAgent(agentId).length > 0) {
@@ -7348,10 +7428,21 @@ function createAgentHistoryRoutes(deps) {
     }
   }
   app3.get("/status", async (c) => {
-    const agentId = await getAuthorizedAgentId(c);
-    if (!agentId) return errorResponse(c, "Unauthorized", 401);
-    const { connected, resolvedAgentId } = await resolveActiveAgent(agentId);
-    const hasSessionFile = !!await findSessionFile(resolvedAgentId);
+    const scope = await getAuthorizedAgentScope(c);
+    if (!scope) return errorResponse(c, "Unauthorized", 401);
+    const { connected, resolvedAgentId } = await resolveActiveAgent(
+      scope.agentId
+    );
+    let hasSessionFile = false;
+    if (process.env.LOBU_SESSION_STORE !== "file") {
+      hasSessionFile = await readLatestSnapshotJsonl(
+        resolvedAgentId,
+        scope.organizationId
+      ) !== null;
+    }
+    if (!hasSessionFile) {
+      hasSessionFile = !!await findSessionFile(resolvedAgentId);
+    }
     return c.json({
       connected: connected || hasSessionFile,
       hasHttpServer: !!connectionManager.getHttpUrl(resolvedAgentId),
@@ -7359,14 +7450,14 @@ function createAgentHistoryRoutes(deps) {
     });
   });
   app3.get("/session/messages", async (c) => {
-    const agentId = await getAuthorizedAgentId(c);
-    if (!agentId) return errorResponse(c, "Unauthorized", 401);
+    const scope = await getAuthorizedAgentScope(c);
+    if (!scope) return errorResponse(c, "Unauthorized", 401);
     const cursor = c.req.query("cursor") || "";
     const limit = Math.min(parseInt(c.req.query("limit") || "50", 10), 200);
     const result = await proxyOrFallback(
-      agentId,
+      scope.agentId,
       `/session/messages?cursor=${cursor}&limit=${limit}`,
-      (resolved) => readSessionMessages(resolved, cursor, limit)
+      (resolved) => readSessionMessages(resolved, cursor, limit, scope.organizationId)
     );
     if (!result) {
       return c.json(
@@ -7383,12 +7474,12 @@ function createAgentHistoryRoutes(deps) {
     return c.json(result.data);
   });
   app3.get("/session/stats", async (c) => {
-    const agentId = await getAuthorizedAgentId(c);
-    if (!agentId) return errorResponse(c, "Unauthorized", 401);
+    const scope = await getAuthorizedAgentScope(c);
+    if (!scope) return errorResponse(c, "Unauthorized", 401);
     const result = await proxyOrFallback(
-      agentId,
+      scope.agentId,
       "/session/stats",
-      readSessionStats
+      (resolved) => readSessionStats(resolved, scope.organizationId)
     );
     if (!result) {
       return c.json({ error: "Agent offline", connected: false }, 503);
@@ -7402,6 +7493,7 @@ var init_agent_history = __esm({
   "src/gateway/routes/public/agent-history.ts"() {
     "use strict";
     init_src();
+    init_client();
     init_helpers();
     init_agent_ownership();
     init_settings_auth();
@@ -9185,8 +9277,10 @@ async function postOAuthCompletionPrompt(params) {
     {},
     agentSettingsStore
   );
-  const conversationState = connectionId ? chatInstanceManager2?.getInstance(connectionId)?.conversationState : void 0;
+  const instance = connectionId ? chatInstanceManager2?.getInstance(connectionId) : void 0;
+  const conversationState = instance?.conversationState;
   const conversationHistory = connectionId && conversationState ? await conversationState.getHistory(connectionId, channelId).catch(() => []) : [];
+  const organizationId = instance?.connection.organizationId ?? void 0;
   const scopeSuffix = scope ? ` (granted scopes: ${scope})` : "";
   const messageText = `[System] Authentication for "${mcpId}" completed successfully${scopeSuffix}. Retry the user's previous request that required ${mcpId} and report the result \u2014 do not ask for confirmation first.`;
   const messageId = randomUUID5();
@@ -9198,6 +9292,7 @@ async function postOAuthCompletionPrompt(params) {
     conversationId: conversationId || channelId,
     teamId: teamId ?? platform,
     agentId,
+    organizationId,
     messageId,
     messageText,
     channelId,
@@ -12603,7 +12698,6 @@ async function storePendingQuestion(questionId, organizationId, connectionId, ex
       connection_id    = EXCLUDED.connection_id,
       expected_user_id = EXCLUDED.expected_user_id,
       entry_payload    = EXCLUDED.entry_payload,
-      created_at       = now(),
       claimed_at       = NULL
   `;
 }
@@ -12622,20 +12716,38 @@ async function claimPendingQuestion(questionId, organizationId, connectionId, ex
   if (rows.length === 0) return null;
   return rows[0].entry_payload ?? null;
 }
-async function sweepStalePendingInteractions(maxAgeMs = 24 * 60 * 60 * 1e3) {
+async function sweepStalePendingInteractions(maxAgeMs = 24 * 60 * 60 * 1e3, limit = DEFAULT_SWEEP_LIMIT) {
   const sql = getDb();
   const cutoff = new Date(Date.now() - maxAgeMs);
   const rows = await sql`
     DELETE FROM pending_interactions
-     WHERE created_at < ${cutoff}
+     WHERE id IN (
+       SELECT id FROM pending_interactions
+        WHERE created_at < ${cutoff}
+        LIMIT ${limit}
+     )
     RETURNING id
   `;
   return rows.map((r) => r.id);
 }
+async function deletePendingQuestion(questionId, organizationId, connectionId, expectedUserId) {
+  const sql = getDb();
+  const rows = await sql`
+    DELETE FROM pending_interactions
+     WHERE id               = ${questionId}
+       AND organization_id  = ${organizationId}
+       AND connection_id    = ${connectionId}
+       AND expected_user_id = ${expectedUserId}
+    RETURNING id
+  `;
+  return rows.length > 0;
+}
+var DEFAULT_SWEEP_LIMIT;
 var init_pending_interaction_store = __esm({
   "src/gateway/connections/pending-interaction-store.ts"() {
     "use strict";
     init_client();
+    DEFAULT_SWEEP_LIMIT = 1e3;
   }
 });
 
@@ -12740,34 +12852,14 @@ function registerInteractionBridge(interactionService, manager, connection, chat
   const PENDING_SENT_SWEEP_INTERVAL_MS = 60 * 60 * 1e3;
   const pendingSentMessages = /* @__PURE__ */ new Map();
   const pendingSentSweepTimer = setInterval(() => {
-    sweepPendingSent().catch((error) => {
-      logger45.warn(
-        { connectionId, error: String(error) },
-        "pendingSentMessages sweep failed"
-      );
-    });
-  }, PENDING_SENT_SWEEP_INTERVAL_MS);
-  pendingSentSweepTimer.unref?.();
-  async function sweepPendingSent() {
     const ttlCutoff = Date.now() - PENDING_SENT_TTL_MS;
     for (const [id, entry] of pendingSentMessages) {
       if (entry.registeredAt <= ttlCutoff) {
         pendingSentMessages.delete(id);
       }
     }
-    let deletedIds = [];
-    try {
-      deletedIds = await sweepStalePendingInteractions();
-    } catch (error) {
-      logger45.debug(
-        { connectionId, error: String(error) },
-        "sweepStalePendingInteractions failed during local sweep"
-      );
-    }
-    for (const id of deletedIds) {
-      pendingSentMessages.delete(id);
-    }
-  }
+  }, PENDING_SENT_SWEEP_INTERVAL_MS);
+  pendingSentSweepTimer.unref?.();
   function rememberSentMessage(questionId, sent) {
     if (!sent) return;
     pendingSentMessages.set(questionId, {
@@ -12856,7 +12948,7 @@ ${event.options.map((o, i) => `${i + 1}. ${o}`).join("\n")}`;
       );
       if (!sent) {
         try {
-          await claimPendingQuestion(
+          await deletePendingQuestion(
             event.id,
             organizationId,
             connectionId,
@@ -14202,6 +14294,7 @@ var init_message_handler_bridge = __esm({
             conversationId,
             teamId: teamId || platform,
             agentId,
+            organizationId: this.connection.organizationId,
             messageId,
             messageText: value,
             channelId,
@@ -14400,15 +14493,47 @@ var init_chat_instance_manager = __esm({
             continue;
           }
           try {
-            if (connection.status === "active") {
+            if (connection.status === "active" || connection.status === "error") {
               await this.startInstance(connection);
+              if (connection.status === "error") {
+                const recoveryOrgId = connection.organizationId;
+                const clearError = () => this.connectionStore.updateConnection(connection.id, {
+                  status: "active",
+                  errorMessage: void 0
+                });
+                if (recoveryOrgId) {
+                  await orgContext.run(
+                    { organizationId: recoveryOrgId },
+                    clearError
+                  );
+                } else {
+                  await clearError();
+                }
+                logger47.info(
+                  { id: connection.id },
+                  "Recovered previously-errored connection"
+                );
+              }
             }
           } catch (error) {
             logger47.error({ id: connection.id, error: String(error) }, "Failed to load connection");
-            await this.connectionStore.updateConnection(connection.id, {
+            const errOrgId = connection.organizationId;
+            const markErrored = () => this.connectionStore.updateConnection(connection.id, {
               status: "error",
               errorMessage: `Startup failed: ${error instanceof Error ? error.message : String(error)}`
             });
+            try {
+              if (errOrgId) {
+                await orgContext.run({ organizationId: errOrgId }, markErrored);
+              } else {
+                await markErrored();
+              }
+            } catch (markErr) {
+              logger47.error(
+                { id: connection.id, error: String(markErr) },
+                "Failed to mark connection as errored"
+              );
+            }
           }
         }
       }
@@ -14663,8 +14788,7 @@ var init_chat_instance_manager = __esm({
         return instance;
       }
       async startInstance(connection) {
-        const callerOrgId = tryGetOrgId();
-        if (!callerOrgId && connection.organizationId) {
+        if (connection.organizationId) {
           return orgContext.run(
             { organizationId: connection.organizationId },
             () => this.startInstanceUnscoped(connection)
@@ -15302,6 +15426,7 @@ var init_chat_instance_manager = __esm({
           channelId: options.channelId,
           teamId: options.teamId,
           agentId: options.agentId,
+          organizationId: connection.organizationId,
           botId: `${name}-platform`,
           platform: name,
           messageText: message,
@@ -15748,6 +15873,7 @@ var init_chat_response_bridge = __esm({
   "src/gateway/connections/chat-response-bridge.ts"() {
     "use strict";
     init_src();
+    init_client();
     init_link_buttons();
     init_platform_strategies();
     logger49 = createLogger("chat-response-bridge");
@@ -15885,6 +16011,31 @@ var init_chat_response_bridge = __esm({
                 "No session file to delete on reset"
               );
             }
+            if (process.env.LOBU_SESSION_STORE !== "file") {
+              try {
+                const sql = getDb();
+                const deleted = await sql`
+              DELETE FROM public.agent_transcript_snapshot s
+              USING public.agents a
+              WHERE s.agent_id = ${agentId}
+                AND s.conversation_id = ${payload.conversationId}
+                AND a.id = s.agent_id
+                AND a.organization_id = s.organization_id
+              RETURNING s.id
+            `;
+                if (deleted.length > 0) {
+                  logger49.info(
+                    { agentId, conversationId: payload.conversationId, count: deleted.length },
+                    "Purged agent_transcript_snapshot rows for session reset"
+                  );
+                }
+              } catch (error) {
+                logger49.warn(
+                  { agentId, conversationId: payload.conversationId, error: String(error) },
+                  "Failed to purge transcript snapshots on session reset (next boot may rehydrate stale history)"
+                );
+              }
+            }
           }
         }
         logger49.info(
@@ -20074,7 +20225,8 @@ var init_runs_queue = __esm({
         const runAtSql = delayMs > 0 ? `now() + ${Number(delayMs) / 1e3}::float * interval '1 second'` : "now()";
         const expiresAtSql = expireInSeconds && expireInSeconds > 0 ? `now() + ${Number(expireInSeconds)}::int * interval '1 second'` : "NULL";
         const sql = getDb();
-        const actionInput = JSON.stringify(data ?? {});
+        const actionInput = sql.json(data ?? {});
+        const organizationIdFromPayload = typeof data?.organizationId === "string" && data.organizationId.length > 0 ? data.organizationId : null;
         const id = await sql.begin(async (tx) => {
           const result = await tx.unsafe(
             `INSERT INTO public.runs (
@@ -20089,9 +20241,10 @@ var init_runs_queue = __esm({
           run_at,
           priority,
           expires_at,
-          retry_delay_seconds
+          retry_delay_seconds,
+          organization_id
         ) VALUES (
-          $1, $2, $3, $4::jsonb, $5, $6, 0, 'pending', ${runAtSql}, $7, ${expiresAtSql}, $8
+          $1, $2, $3, $4, $5, $6, 0, 'pending', ${runAtSql}, $7, ${expiresAtSql}, $8, $9
         )
         ON CONFLICT (idempotency_key)
           WHERE idempotency_key IS NOT NULL
@@ -20106,7 +20259,8 @@ var init_runs_queue = __esm({
               idempotencyKey,
               maxAttempts,
               priority,
-              retryDelaySeconds
+              retryDelaySeconds,
+              organizationIdFromPayload
             ]
           );
           if (result.length === 0 && idempotencyKey) {
@@ -21020,6 +21174,34 @@ var init_user_agents_store = __esm({
         const agents = await this.listAgents(platform, userId, organizationId);
         return agents.includes(agentId);
       }
+      /**
+       * Resolve the orgs in which `(platform, userId)` owns `agentId`.
+       *
+       * Reads `agent_users` directly, which IS the per-org owner mapping —
+       * unlike `agents.{owner_platform, owner_user_id}` (used by the prior
+       * `resolveAuthorizedOrgId` in agent-ownership.ts) those columns are
+       * legacy and unique on `(owner_platform, owner_user_id, id)` only by
+       * convention; they can return the wrong org when the same human owns
+       * the same agentId across two orgs. The authoritative mapping for
+       * "this user is allowed to read this agent's snapshot in org X" lives
+       * here. Codex round 2 finding B on PR #865.
+       *
+       * Returns an empty array if the user owns no instance of `agentId`.
+       * Typically returns 1 element; >1 means the same user has the same
+       * agentId in multiple orgs (rare but legal).
+       */
+      async findAgentOrganizations(platform, userId, agentId) {
+        const sql = getDb();
+        const rows = await sql`
+      SELECT organization_id
+      FROM agent_users
+      WHERE platform = ${platform}
+        AND user_id = ${userId}
+        AND agent_id = ${agentId}
+      ORDER BY organization_id
+    `;
+        return rows.map((r) => r.organization_id);
+      }
     };
   }
 });
@@ -21879,10 +22061,183 @@ var init_job_router = __esm({
   }
 });
 
-// src/gateway/gateway/index.ts
+// src/gateway/gateway/transcript-routes.ts
 import { Hono as Hono18 } from "hono";
+function authenticate(c) {
+  const authHeader = c.req.header("authorization");
+  if (!authHeader?.startsWith("Bearer ")) return null;
+  const token = authHeader.substring(7);
+  return verifyWorkerToken(token);
+}
+async function isRunOwnedByJwtScope(runId, organizationId, agentId, conversationId) {
+  const sql = getDb();
+  const rows = await sql`
+    SELECT 1 AS ok FROM public.runs
+    WHERE id = ${runId}
+      AND organization_id = ${organizationId}
+      AND CASE jsonb_typeof(action_input)
+            WHEN 'object' THEN action_input ->> 'agentId'
+            WHEN 'string' THEN (action_input #>> '{}')::jsonb ->> 'agentId'
+            ELSE NULL
+          END = ${agentId}
+      AND CASE jsonb_typeof(action_input)
+            WHEN 'object' THEN action_input ->> 'conversationId'
+            WHEN 'string' THEN (action_input #>> '{}')::jsonb ->> 'conversationId'
+            ELSE NULL
+          END = ${conversationId}
+    LIMIT 1
+  `;
+  return rows.length > 0;
+}
+function createTranscriptRoutes() {
+  const app3 = new Hono18();
+  app3.get("/snapshot", async (c) => {
+    const token = authenticate(c);
+    if (!token) return c.json({ error: "Invalid token" }, 401);
+    const { organizationId, agentId, conversationId } = token;
+    if (!organizationId || !agentId || !conversationId) {
+      return c.json({ error: "Token missing required scope" }, 400);
+    }
+    const sql = getDb();
+    const rows = await sql`
+      SELECT snapshot_jsonl
+      FROM public.agent_transcript_snapshot
+      WHERE organization_id = ${organizationId}
+        AND agent_id = ${agentId}
+        AND conversation_id = ${conversationId}
+        AND terminal_status = 'completed'
+      ORDER BY run_id DESC
+      LIMIT 1
+    `;
+    const row = rows[0];
+    if (!row) {
+      return c.json({ error: "No snapshot found" }, 404);
+    }
+    return c.body(row.snapshot_jsonl, 200, {
+      "content-type": "application/x-ndjson; charset=utf-8"
+    });
+  });
+  app3.post("/snapshot", async (c) => {
+    const token = authenticate(c);
+    if (!token) return c.json({ error: "Invalid token" }, 401);
+    const { organizationId, agentId, conversationId } = token;
+    if (!organizationId || !agentId || !conversationId) {
+      return c.json({ error: "Token missing required scope" }, 400);
+    }
+    let body2;
+    try {
+      body2 = await c.req.json();
+    } catch {
+      return c.json({ error: "Invalid JSON body" }, 400);
+    }
+    const terminalStatus = body2.terminalStatus;
+    const snapshotJsonl = body2.snapshotJsonl;
+    if (terminalStatus !== "completed" && terminalStatus !== "failed" && terminalStatus !== "timeout" && terminalStatus !== "cancelled") {
+      return c.json({ error: "Invalid terminalStatus" }, 400);
+    }
+    if (typeof snapshotJsonl !== "string" || snapshotJsonl.length === 0) {
+      return c.json({ error: "Missing snapshotJsonl" }, 400);
+    }
+    const byteSize = Buffer.byteLength(snapshotJsonl, "utf-8");
+    if (byteSize > MAX_SNAPSHOT_BYTES) {
+      logger72.warn(
+        `Rejecting oversize snapshot (${byteSize} > ${MAX_SNAPSHOT_BYTES} bytes) for (${organizationId}, ${agentId}, ${conversationId})`
+      );
+      return c.json({ error: "Snapshot too large" }, 413);
+    }
+    const rawRunId = body2.runId;
+    const runId = typeof rawRunId === "number" && Number.isFinite(rawRunId) && rawRunId > 0 ? rawRunId : null;
+    if (runId === null) {
+      return c.json({ error: "Missing or invalid runId" }, 400);
+    }
+    if (token.runId !== runId) {
+      logger72.warn(
+        `Token runId mismatch: token.runId=${token.runId ?? "<absent>"} body.runId=${runId}; rejecting snapshot`
+      );
+      return c.json({ error: "runId out of scope" }, 403);
+    }
+    if (!await isRunOwnedByJwtScope(
+      runId,
+      organizationId,
+      agentId,
+      conversationId
+    )) {
+      logger72.warn(
+        `Run ${runId} does not belong to (${organizationId}, ${agentId}, ${conversationId}); rejecting snapshot`
+      );
+      return c.json({ error: "runId out of scope" }, 403);
+    }
+    const sql = getDb();
+    try {
+      const inserted = await sql`
+        INSERT INTO public.agent_transcript_snapshot
+          (organization_id, agent_id, conversation_id, run_id,
+           snapshot_jsonl, byte_size, terminal_status)
+        VALUES
+          (${organizationId}, ${agentId}, ${conversationId}, ${runId},
+           ${snapshotJsonl}, ${byteSize}, ${terminalStatus})
+        ON CONFLICT (organization_id, agent_id, conversation_id, run_id)
+          DO NOTHING
+        RETURNING id
+      `;
+      if (inserted.length === 0) {
+        return c.json({ error: "Snapshot already exists for run" }, 409);
+      }
+      logger72.info(
+        `Wrote snapshot id=${inserted[0].id} run_id=${runId} byte_size=${byteSize} status=${terminalStatus}`
+      );
+      return c.json({ id: inserted[0].id });
+    } catch (err) {
+      logger72.error(
+        `Snapshot INSERT failed: ${err instanceof Error ? err.message : String(err)}`
+      );
+      return c.json({ error: "Internal error" }, 500);
+    }
+  });
+  app3.delete("/snapshot", async (c) => {
+    const token = authenticate(c);
+    if (!token) return c.json({ error: "Invalid token" }, 401);
+    const { organizationId, agentId, conversationId } = token;
+    if (!organizationId || !agentId || !conversationId) {
+      return c.json({ error: "Token missing required scope" }, 400);
+    }
+    const sql = getDb();
+    try {
+      const deleted = await sql`
+        DELETE FROM public.agent_transcript_snapshot
+        WHERE organization_id = ${organizationId}
+          AND agent_id = ${agentId}
+          AND conversation_id = ${conversationId}
+        RETURNING id
+      `;
+      logger72.info(
+        `Purged ${deleted.length} snapshot row(s) for (${organizationId}, ${agentId}, ${conversationId}) on session reset`
+      );
+      return c.json({ deleted: deleted.length });
+    } catch (err) {
+      logger72.error(
+        `Snapshot DELETE failed: ${err instanceof Error ? err.message : String(err)}`
+      );
+      return c.json({ error: "Internal error" }, 500);
+    }
+  });
+  return app3;
+}
+var logger72, MAX_SNAPSHOT_BYTES;
+var init_transcript_routes = __esm({
+  "src/gateway/gateway/transcript-routes.ts"() {
+    "use strict";
+    init_src();
+    init_client();
+    logger72 = createLogger("worker-transcript");
+    MAX_SNAPSHOT_BYTES = 4 * 1024 * 1024;
+  }
+});
+
+// src/gateway/gateway/index.ts
+import { Hono as Hono19 } from "hono";
 import { stream } from "hono/streaming";
-var logger72, WorkerGateway;
+var logger73, WorkerGateway;
 var init_gateway2 = __esm({
   "src/gateway/gateway/index.ts"() {
     "use strict";
@@ -21893,7 +22248,8 @@ var init_gateway2 = __esm({
     init_model_selection();
     init_connection_manager();
     init_job_router();
-    logger72 = createLogger("worker-gateway");
+    init_transcript_routes();
+    logger73 = createLogger("worker-gateway");
     WorkerGateway = class {
       app;
       connectionManager;
@@ -21917,7 +22273,7 @@ var init_gateway2 = __esm({
         this.providerCatalogService = providerCatalogService;
         this.agentSettingsStore = agentSettingsStore;
         this.secretStore = secretStore;
-        this.app = new Hono18();
+        this.app = new Hono19();
         this.setupRoutes();
       }
       /**
@@ -21942,7 +22298,8 @@ var init_gateway2 = __esm({
           "/session-context",
           (c) => this.handleSessionContextRequest(c)
         );
-        logger72.debug("Worker gateway routes registered");
+        this.app.route("/transcript", createTranscriptRoutes());
+        logger73.debug("Worker gateway routes registered");
       }
       async enrichMcpStatus(mcpStatus, agentId, userId) {
         const secretStore = this.secretStore;
@@ -21971,7 +22328,7 @@ var init_gateway2 = __esm({
                 mcp.id
               );
             } catch (error) {
-              logger72.warn("Failed to look up stored MCP credential", {
+              logger73.warn("Failed to look up stored MCP credential", {
                 mcpId: mcp.id,
                 agentId,
                 userId,
@@ -22028,6 +22385,29 @@ var init_gateway2 = __esm({
               });
             }
           };
+          let connectionAdded = false;
+          let cleanupRan = false;
+          let aborted = false;
+          const runCleanup = () => {
+            if (cleanupRan) return;
+            cleanupRan = true;
+            aborted = true;
+            if (!connectionAdded) {
+              return;
+            }
+            const current = this.connectionManager.getConnection(deploymentName);
+            if (current && current.writer !== sseWriter) {
+              logger73.debug(
+                `Ignoring stale disconnect for ${deploymentName} (replaced by newer SSE)`
+              );
+              return;
+            }
+            this.jobRouter.pauseWorker(deploymentName).catch((err) => {
+              logger73.error(`Failed to pause worker ${deploymentName}:`, err);
+            });
+            this.connectionManager.removeConnection(deploymentName);
+          };
+          sseWriter.onClose(runCleanup);
           const detachAbortBridge = bindRequestAbortToStream(
             requestSignal,
             streamWriter
@@ -22037,8 +22417,13 @@ var init_gateway2 = __esm({
           c.header("Connection", "keep-alive");
           c.header("X-Accel-Buffering", "no");
           await this.jobRouter.pauseWorker(deploymentName);
+          if (aborted || requestSignal?.aborted) {
+            detachAbortBridge();
+            runCleanup();
+            return;
+          }
           if (this.connectionManager.isConnected(deploymentName)) {
-            logger72.info(
+            logger73.info(
               `Cleaning up stale connection for ${deploymentName} before new SSE`
             );
             this.connectionManager.removeConnection(deploymentName);
@@ -22051,21 +22436,14 @@ var init_gateway2 = __esm({
             sseWriter,
             httpPort
           );
+          connectionAdded = true;
+          if (aborted || requestSignal?.aborted) {
+            detachAbortBridge();
+            runCleanup();
+            return;
+          }
           await this.jobRouter.registerWorker(deploymentName);
           await this.jobRouter.resumeWorker(deploymentName);
-          sseWriter.onClose(() => {
-            const current = this.connectionManager.getConnection(deploymentName);
-            if (current && current.writer !== sseWriter) {
-              logger72.debug(
-                `Ignoring stale disconnect for ${deploymentName} (replaced by newer SSE)`
-              );
-              return;
-            }
-            this.jobRouter.pauseWorker(deploymentName).catch((err) => {
-              logger72.error(`Failed to pause worker ${deploymentName}:`, err);
-            });
-            this.connectionManager.removeConnection(deploymentName);
-          });
           try {
             while (!isClosed) {
               await streamWriter.sleep(1e3);
@@ -22088,36 +22466,37 @@ var init_gateway2 = __esm({
         try {
           const body2 = await c.req.json();
           const { jobId, ...responseData } = body2;
-          const enrichedResponse = auth.tokenData.connectionId && (!responseData.platformMetadata || typeof responseData.platformMetadata === "object") ? {
-            ...responseData,
+          const orgEnriched = auth.tokenData.organizationId && !responseData.organizationId ? { ...responseData, organizationId: auth.tokenData.organizationId } : responseData;
+          const enrichedResponse = auth.tokenData.connectionId && (!orgEnriched.platformMetadata || typeof orgEnriched.platformMetadata === "object") ? {
+            ...orgEnriched,
             platformMetadata: {
-              ...responseData.platformMetadata || {},
+              ...orgEnriched.platformMetadata || {},
               connectionId: auth.tokenData.connectionId
             }
-          } : responseData;
+          } : orgEnriched;
           if (jobId) {
             this.jobRouter.acknowledgeJob(jobId);
           }
           if (enrichedResponse.received) {
             if (enrichedResponse.heartbeat) {
-              logger72.debug(
+              logger73.debug(
                 `[WORKER-GATEWAY] Received heartbeat ACK from ${deploymentName}`
               );
             }
             return c.json({ success: true });
           }
-          logger72.info(
+          logger73.info(
             `[WORKER-GATEWAY] Received response with fields: ${Object.keys(enrichedResponse).join(", ")}`
           );
           if (enrichedResponse.delta) {
-            logger72.info(
+            logger73.info(
               `[WORKER-GATEWAY] Stream delta: deltaLength=${enrichedResponse.delta.length}`
             );
           }
           await this.queue.send("thread_response", enrichedResponse);
           return c.json({ success: true });
         } catch (error) {
-          logger72.error(`Error handling worker response: ${error}`);
+          logger73.error(`Error handling worker response: ${error}`);
           return c.json({ error: "Failed to process response" }, 500);
         }
       }
@@ -22206,7 +22585,7 @@ var init_gateway2 = __esm({
                   mcpInstructions[result.value.mcpId] = result.value.instructions;
                 }
               } else {
-                logger72.error("MCP tool fetch rejected", {
+                logger73.error("MCP tool fetch rejected", {
                   reason: result.reason instanceof Error ? result.reason.message : String(result.reason)
                 });
               }
@@ -22234,13 +22613,13 @@ var init_gateway2 = __esm({
                 }
               }
             } catch (error) {
-              logger72.error("Failed to fetch skills config for worker sync", {
+              logger73.error("Failed to fetch skills config for worker sync", {
                 error
               });
             }
           }
           const mergedSkillsInstructions = contextData.skillsInstructions || "";
-          logger72.info(
+          logger73.info(
             `Session context for ${userId}: ${Object.keys(mcpConfig.mcpServers || {}).length} MCPs, ${contextData.agentInstructions.length} chars agent instructions, ${contextData.platformInstructions.length} chars platform instructions, ${contextData.networkInstructions.length} chars network instructions, ${mergedSkillsInstructions.length} chars skills instructions, ${enrichedMcpStatus.length} MCP status entries, ${Object.keys(mcpTools).length} MCP tool lists, ${Object.keys(mcpInstructions).length} MCP instructions, ${skillsConfig.length} skills, provider: ${providerConfig.defaultProvider || "none"}`
           );
           return c.json({
@@ -22257,7 +22636,7 @@ var init_gateway2 = __esm({
             skillsConfig
           });
         } catch (error) {
-          logger72.error("Failed to generate session context", { err: error });
+          logger73.error("Failed to generate session context", { err: error });
           return c.json({ error: "session_context_error" }, 500);
         }
       }
@@ -22269,11 +22648,11 @@ var init_gateway2 = __esm({
         const token = authHeader.substring(7);
         const tokenData = verifyWorkerToken(token);
         if (!tokenData) {
-          logger72.warn("Invalid token");
+          logger73.warn("Invalid token");
           return null;
         }
         if (tokenData.jti && await getRevokedTokenStore().isRevoked(tokenData.jti)) {
-          logger72.warn("Revoked worker token");
+          logger73.warn("Revoked worker token");
           return null;
         }
         return { tokenData, token };
@@ -22389,12 +22768,12 @@ var init_gateway2 = __esm({
 });
 
 // src/gateway/infrastructure/queue/queue-producer.ts
-var logger73, QueueProducer;
+var logger74, QueueProducer;
 var init_queue_producer = __esm({
   "src/gateway/infrastructure/queue/queue-producer.ts"() {
     "use strict";
     init_src();
-    logger73 = createLogger("queue-producer");
+    logger74 = createLogger("queue-producer");
     QueueProducer = class {
       queue;
       isInitialized = false;
@@ -22409,9 +22788,9 @@ var init_queue_producer = __esm({
         try {
           await this.queue.createQueue("messages");
           this.isInitialized = true;
-          logger73.debug("Queue producer initialized");
+          logger74.debug("Queue producer initialized");
         } catch (error) {
-          logger73.error("Failed to initialize queue producer:", error);
+          logger74.error("Failed to initialize queue producer:", error);
           throw error;
         }
       }
@@ -22420,7 +22799,7 @@ var init_queue_producer = __esm({
        */
       async stop() {
         this.isInitialized = false;
-        logger73.debug("Queue producer stopped");
+        logger74.debug("Queue producer stopped");
       }
       /**
        * Enqueue any message (direct or thread) to the single 'messages' queue
@@ -22441,12 +22820,12 @@ var init_queue_producer = __esm({
             singletonKey: rawSingletonKey.replace(/:/g, "-")
             // Prevent duplicates within canonical conversation identity
           });
-          logger73.info(
+          logger74.info(
             `Enqueued message job ${jobId} for user ${payload.userId}, conversation ${payload.conversationId}`
           );
           return jobId || "job-sent";
         } catch (error) {
-          logger73.error(
+          logger74.error(
             `Failed to enqueue message for user ${payload.userId}:`,
             error
           );
@@ -22495,12 +22874,12 @@ function assertConnectionId(connectionId, kind) {
     );
   }
 }
-var logger74, SAFE_LINK_BUTTON_SCHEMES, InteractionService;
+var logger75, SAFE_LINK_BUTTON_SCHEMES, InteractionService;
 var init_interactions2 = __esm({
   "src/gateway/interactions.ts"() {
     "use strict";
     init_src();
-    logger74 = createLogger("interactions");
+    logger75 = createLogger("interactions");
     SAFE_LINK_BUTTON_SCHEMES = /* @__PURE__ */ new Set(["http:", "https:"]);
     InteractionService = class extends EventEmitter {
       beforeCreateHook;
@@ -22531,7 +22910,7 @@ var init_interactions2 = __esm({
           question,
           options
         };
-        logger74.info(
+        logger75.info(
           `Posted question ${posted.id} for conversation ${conversationId}`
         );
         this.emit("question:created", posted);
@@ -22564,7 +22943,7 @@ var init_interactions2 = __esm({
           args,
           grantPattern
         };
-        logger74.info(
+        logger75.info(
           `Posted tool approval ${posted.id} for ${mcpId}/${toolName} agent=${agentId}`
         );
         this.emit("tool:approval-needed", posted);
@@ -22593,7 +22972,7 @@ var init_interactions2 = __esm({
           body: body2,
           linkType
         };
-        logger74.info(
+        logger75.info(
           `Posted link button ${posted.id} for conversation ${conversationId} (${linkType})`
         );
         this.emit("link-button:created", posted);
@@ -22634,7 +23013,7 @@ var init_interactions2 = __esm({
           platform,
           text
         };
-        logger74.info(
+        logger75.info(
           `Posted status message ${posted.id} for conversation ${conversationId}`
         );
         this.emit("status-message:created", posted);
@@ -22654,7 +23033,7 @@ var init_interactions2 = __esm({
           blocking: false,
           prompts
         };
-        logger74.info(
+        logger75.info(
           `Created suggestion ${suggestion.id} for conversation ${conversationId}`
         );
         this.emit("suggestion:created", suggestion);
@@ -22725,12 +23104,12 @@ function findMatchingRule(hostname, rules) {
 function hashPolicy(organizationId, agentId, judgeName, policy) {
   return crypto3.createHash("sha256").update(`${organizationId} ${agentId} ${judgeName} ${policy}`).digest("hex").slice(0, 16);
 }
-var logger75, PolicyStore;
+var logger76, PolicyStore;
 var init_policy_store = __esm({
   "src/gateway/permissions/policy-store.ts"() {
     "use strict";
     init_src();
-    logger75 = createLogger("policy-store");
+    logger76 = createLogger("policy-store");
     PolicyStore = class _PolicyStore {
       policies = /* @__PURE__ */ new Map();
       static composeKey(organizationId, agentId) {
@@ -22739,7 +23118,7 @@ var init_policy_store = __esm({
       set(organizationId, agentId, bundle) {
         const prepared = prepareBundle(organizationId, agentId, bundle);
         this.policies.set(_PolicyStore.composeKey(organizationId, agentId), prepared);
-        logger75.debug("Set egress policy bundle", {
+        logger76.debug("Set egress policy bundle", {
           organizationId,
           agentId,
           domains: prepared.judgedDomains.length,
@@ -22770,7 +23149,7 @@ var init_policy_store = __esm({
         const judgeName = matched.judge ?? "default";
         const judge = prepared.preparedJudges[judgeName];
         if (!judge) {
-          logger75.warn(
+          logger76.warn(
             "Judge rule matched but named policy not found \u2014 failing closed",
             { organizationId, agentId, hostname, judgeName }
           );
@@ -22788,7 +23167,7 @@ var init_policy_store = __esm({
 });
 
 // src/gateway/proxy/secret-proxy.ts
-import { Hono as Hono19 } from "hono";
+import { Hono as Hono20 } from "hono";
 function defaultPlaceholderTtlSeconds() {
   const raw = process.env.SECRET_PLACEHOLDER_TTL_MS;
   if (raw) {
@@ -22803,8 +23182,8 @@ function lookupPlaceholderMapping(placeholder, expectedOrganizationId) {
   const uuid = placeholder.slice(prefixIdx + PLACEHOLDER_PREFIX.length);
   const mapping = placeholderCache.get(uuid);
   if (!mapping) return null;
-  if (expectedOrganizationId && mapping.organizationId && mapping.organizationId !== expectedOrganizationId) {
-    logger76.warn(
+  if (expectedOrganizationId !== void 0 && mapping.organizationId !== expectedOrganizationId) {
+    logger77.warn(
       {
         mappingAgentId: mapping.agentId,
         mappingOrg: mapping.organizationId,
@@ -22814,6 +23193,15 @@ function lookupPlaceholderMapping(placeholder, expectedOrganizationId) {
     );
     return null;
   }
+  if (!mapping.organizationId) {
+    logger77.warn(
+      {
+        mappingAgentId: mapping.agentId,
+        expectedOrg: expectedOrganizationId
+      },
+      "Placeholder mapping accessed without organizationId \u2014 legacy row, schedule rotation"
+    );
+  }
   return mapping;
 }
 function safeDecodePathSegment(value) {
@@ -22845,13 +23233,14 @@ function generatePlaceholder(agentId, envVarName, secretRef, deploymentName, opt
   );
   return `${PLACEHOLDER_PREFIX}${uuid}`;
 }
-var logger76, PLACEHOLDER_PREFIX, RESOLVE_FAILURE_THRESHOLD, RESOLVE_FAILURE_WINDOW_MS, ResolutionFailureLimiter, resolutionFailureLimiter, PlaceholderCache, placeholderCache, SecretProxy;
+var logger77, PLACEHOLDER_PREFIX, RESOLVE_FAILURE_THRESHOLD, RESOLVE_FAILURE_WINDOW_MS, ResolutionFailureLimiter, resolutionFailureLimiter, PlaceholderCache, placeholderCache, SecretProxy;
 var init_secret_proxy = __esm({
   "src/gateway/proxy/secret-proxy.ts"() {
     "use strict";
     init_src();
+    init_org_context();
     init_rate_limiter();
-    logger76 = createLogger("secret-proxy");
+    logger77 = createLogger("secret-proxy");
     PLACEHOLDER_PREFIX = "lobu_secret_";
     RESOLVE_FAILURE_THRESHOLD = 20;
     RESOLVE_FAILURE_WINDOW_MS = 5 * 60 * 1e3;
@@ -22961,11 +23350,11 @@ var init_secret_proxy = __esm({
         this.slugMap = /* @__PURE__ */ new Map();
         for (const upstream of config.providerUpstreams ?? []) {
           this.slugMap.set(upstream.slug, upstream.upstreamBaseUrl);
-          logger76.debug(
+          logger77.debug(
             `Registered provider upstream: ${upstream.slug} -> ${upstream.upstreamBaseUrl}`
           );
         }
-        this.app = new Hono19();
+        this.app = new Hono20();
         this.setupRoutes();
       }
       setAuthProfilesManager(manager) {
@@ -22996,7 +23385,7 @@ var init_secret_proxy = __esm({
         if (providerId) {
           this.slugToProviderId.set(upstream.slug, providerId);
         }
-        logger76.debug(
+        logger77.debug(
           `Registered provider upstream: ${upstream.slug} -> ${upstream.upstreamBaseUrl}${providerId ? ` (providerId: ${providerId})` : ""}`
         );
       }
@@ -23018,7 +23407,7 @@ var init_secret_proxy = __esm({
         try {
           return await this.forward(c);
         } catch (error) {
-          logger76.error("Secret proxy error:", error);
+          logger77.error("Secret proxy error:", error);
           return c.json({ error: "Internal proxy error" }, 500);
         }
       }
@@ -23114,12 +23503,12 @@ var init_secret_proxy = __esm({
             const { shouldLog, nowThrottled } = resolutionFailureLimiter.recordFailure(source);
             if (shouldLog) {
               if (nowThrottled) {
-                logger76.warn(
+                logger77.warn(
                   { source },
                   "Throttling placeholder resolution for source after repeated failures"
                 );
               } else {
-                logger76.warn({ source }, "Failed to resolve secret placeholder");
+                logger77.warn({ source }, "Failed to resolve secret placeholder");
               }
             }
             return "";
@@ -23170,9 +23559,13 @@ var init_secret_proxy = __esm({
             const orgId = await this.agentOrgResolver(urlAgentId);
             if (orgId) expectedOrganizationId = orgId;
           } catch (err) {
-            logger76.warn(
+            logger77.error(
               { urlAgentId, err: String(err) },
-              "agentOrgResolver failed \u2014 falling through without org expectation"
+              "agentOrgResolver failed \u2014 rejecting request to preserve org isolation"
+            );
+            return c.json(
+              { error: "Service Unavailable: failed to resolve agent organization" },
+              503
             );
           }
         }
@@ -23183,26 +23576,26 @@ var init_secret_proxy = __esm({
               expectedOrganizationId
             );
             if (!mapping) {
-              logger76.warn(
+              logger77.warn(
                 { urlAgentId },
                 "Rejecting proxy request: placeholder did not resolve"
               );
               return c.json({ error: "Unauthorized" }, 401);
             }
             if (mapping.agentId !== urlAgentId) {
-              logger76.warn(
+              logger77.warn(
                 { urlAgentId, mappingAgentId: mapping.agentId },
                 "Rejecting proxy request: placeholder agentId does not match URL"
               );
               return c.json({ error: "Forbidden" }, 403);
             }
           } else if (callerToken) {
-            logger76.debug(
+            logger77.debug(
               { urlAgentId },
               "Proxy request authenticated by non-placeholder token; agentId binding skipped"
             );
           } else {
-            logger76.warn(
+            logger77.warn(
               { urlAgentId },
               "Rejecting proxy request: names an agent but carries no auth header"
             );
@@ -23225,17 +23618,23 @@ var init_secret_proxy = __esm({
         if (urlAgentId && resolvedSlug && this.authProfilesManager) {
           const providerId = this.slugToProviderId.get(resolvedSlug);
           if (providerId) {
-            const profile = await this.authProfilesManager.getBestProfile(
-              urlAgentId,
-              providerId,
-              void 0,
-              providerContext
+            const runWithOrg = (fn) => expectedOrganizationId ? orgContext.run({ organizationId: expectedOrganizationId }, fn) : fn();
+            const authProfilesManager = this.authProfilesManager;
+            const profile = await runWithOrg(
+              () => authProfilesManager.getBestProfile(
+                urlAgentId,
+                providerId,
+                void 0,
+                providerContext
+              )
             );
             const userIdForRefresh = providerContext?.userId;
-            const credential = profile && userIdForRefresh ? await this.authProfilesManager.ensureFreshCredential(profile, {
-              userId: userIdForRefresh,
-              agentId: urlAgentId
-            }) : profile?.credential;
+            const credential = profile && userIdForRefresh ? await runWithOrg(
+              () => authProfilesManager.ensureFreshCredential(profile, {
+                userId: userIdForRefresh,
+                agentId: urlAgentId
+              })
+            ) : profile?.credential;
             if (credential) {
               headers.authorization = `Bearer ${credential}`;
             } else if (this.systemKeyResolver) {
@@ -23243,7 +23642,7 @@ var init_secret_proxy = __esm({
               if (systemKey) {
                 headers.authorization = `Bearer ${systemKey}`;
               } else {
-                logger76.warn(
+                logger77.warn(
                   `No auth profile or system key for agent ${urlAgentId}, provider ${providerId}`
                 );
                 return c.json(
@@ -23258,7 +23657,7 @@ var init_secret_proxy = __esm({
                 );
               }
             } else {
-              logger76.warn(
+              logger77.warn(
                 `No auth profile for agent ${urlAgentId}, provider ${providerId}`
               );
               return c.json(
@@ -23273,7 +23672,7 @@ var init_secret_proxy = __esm({
               );
             }
           } else {
-            logger76.warn(`No providerId mapping for slug "${resolvedSlug}"`);
+            logger77.warn(`No providerId mapping for slug "${resolvedSlug}"`);
           }
         } else {
           const source = urlAgentId ?? getClientIp({
@@ -23301,10 +23700,10 @@ var init_secret_proxy = __esm({
             }
           }
         }
-        logger76.info(`Forwarding to upstream: ${method} ${upstream}`);
+        logger77.info(`Forwarding to upstream: ${method} ${upstream}`);
         const response = await fetch(upstream, { method, headers, body: body2 });
         if (!response.ok) {
-          logger76.warn(
+          logger77.warn(
             `Upstream returned ${response.status} for ${method} ${upstream}`
           );
         }
@@ -23341,14 +23740,14 @@ var init_secret_proxy = __esm({
 });
 
 // src/gateway/proxy/token-refresh-job.ts
-var logger77, EXPIRY_BUFFER_MS, TokenRefreshJob;
+var logger78, EXPIRY_BUFFER_MS, TokenRefreshJob;
 var init_token_refresh_job = __esm({
   "src/gateway/proxy/token-refresh-job.ts"() {
     "use strict";
     init_src();
     init_client();
     init_org_context();
-    logger77 = createLogger("token-refresh-job");
+    logger78 = createLogger("token-refresh-job");
     EXPIRY_BUFFER_MS = 5 * 60 * 1e3;
     TokenRefreshJob = class {
       constructor(authProfilesManager, refreshableProviders) {
@@ -23375,7 +23774,7 @@ var init_token_refresh_job = __esm({
               () => this.maybeRefresh(userId, agentId)
             );
           } catch (err) {
-            logger77.warn(
+            logger78.warn(
               { userId, agentId, organizationId, err: String(err) },
               "Token refresh failed for user/agent \u2014 continuing scan"
             );
@@ -23398,7 +23797,7 @@ var init_token_refresh_job = __esm({
       async refreshForUserAgent(userId, agentId) {
         const organizationId = await this.lookupAgentOrg(agentId);
         if (organizationId === null) {
-          logger77.warn(
+          logger78.warn(
             { userId, agentId },
             "Skipping token refresh \u2014 agent has no org row (deleted?)"
           );
@@ -23445,7 +23844,7 @@ var init_token_refresh_job = __esm({
           const expiresAt = oauthProfile.metadata.expiresAt || 0;
           const isExpiring = expiresAt <= Date.now() + EXPIRY_BUFFER_MS;
           if (!isExpiring) continue;
-          logger77.info(
+          logger78.info(
             `Refreshing ${providerId} token for user ${userId} agent ${agentId} profile ${oauthProfile.id}`,
             { expiresAt: new Date(expiresAt).toISOString() }
           );
@@ -23469,11 +23868,11 @@ var init_token_refresh_job = __esm({
               },
               makePrimary: false
             });
-            logger77.info(
+            logger78.info(
               `Token refreshed for user ${userId} agent ${agentId} (${providerId})`
             );
           } catch (error) {
-            logger77.error(
+            logger78.error(
               `Failed to refresh ${providerId} token for user ${userId} agent ${agentId}`,
               {
                 error,
@@ -24045,12 +24444,12 @@ async function loadBedrockModelsFromAws() {
 function loadFallbackRegistryModels() {
   return getModels("amazon-bedrock").map(normalizeRegistryModel).sort(sortModels);
 }
-var logger78, CACHE_TTL_MS3, BedrockModelCatalog;
+var logger79, CACHE_TTL_MS3, BedrockModelCatalog;
 var init_bedrock_model_catalog = __esm({
   "src/gateway/services/bedrock-model-catalog.ts"() {
     "use strict";
     init_src();
-    logger78 = createLogger("bedrock-model-catalog");
+    logger79 = createLogger("bedrock-model-catalog");
     CACHE_TTL_MS3 = 5 * 60 * 1e3;
     BedrockModelCatalog = class {
       cacheTtlMs;
@@ -24073,7 +24472,7 @@ var init_bedrock_model_catalog = __esm({
           };
           return models;
         } catch (error) {
-          logger78.warn(
+          logger79.warn(
             {
               error: error instanceof Error ? error.message : String(error)
             },
@@ -24107,7 +24506,7 @@ var init_bedrock_model_catalog = __esm({
 // src/gateway/services/bedrock-openai-service.ts
 import { getModel } from "@mariozechner/pi-ai";
 import { streamBedrock } from "@mariozechner/pi-ai/dist/providers/amazon-bedrock.js";
-import { Hono as Hono20 } from "hono";
+import { Hono as Hono21 } from "hono";
 function parseDataUrl(url) {
   if (!url) return null;
   const match = url.match(/^data:([^;,]+);base64,(.+)$/);
@@ -24394,16 +24793,16 @@ function createSseStream(requestModel, stream2, includeUsage) {
     }
   });
 }
-var logger79, BedrockOpenAIService;
+var logger80, BedrockOpenAIService;
 var init_bedrock_openai_service = __esm({
   "src/gateway/services/bedrock-openai-service.ts"() {
     "use strict";
     init_src();
     init_middleware();
     init_bedrock_model_catalog();
-    logger79 = createLogger("bedrock-openai-service");
+    logger80 = createLogger("bedrock-openai-service");
     BedrockOpenAIService = class {
-      app = new Hono20();
+      app = new Hono21();
       modelCatalog;
       modelResolver;
       bedrockStreamer;
@@ -24492,7 +24891,7 @@ var init_bedrock_openai_service = __esm({
         const context2 = buildBedrockContext(request2);
         const stopSequences = Array.isArray(request2.stop) ? request2.stop : typeof request2.stop === "string" ? [request2.stop] : [];
         const toolChoice = mapToolChoice(request2.tool_choice);
-        logger79.info(
+        logger80.info(
           {
             modelId: request2.model,
             region,
@@ -24577,12 +24976,12 @@ function buildRegistryMap(configAgents) {
   }
   return result;
 }
-var logger80, DeclaredAgentRegistry;
+var logger81, DeclaredAgentRegistry;
 var init_declared_agent_registry = __esm({
   "src/gateway/services/declared-agent-registry.ts"() {
     "use strict";
     init_src();
-    logger80 = createLogger("declared-agent-registry");
+    logger81 = createLogger("declared-agent-registry");
     DeclaredAgentRegistry = class {
       entries = /* @__PURE__ */ new Map();
       has(agentId) {
@@ -24603,7 +25002,7 @@ var init_declared_agent_registry = __esm({
         for (const [agentId, entry] of next) {
           this.entries.set(agentId, entry);
         }
-        logger80.debug(`Registry now holds ${this.entries.size} declared agent(s)`);
+        logger81.debug(`Registry now holds ${this.entries.size} declared agent(s)`);
       }
     };
   }
@@ -24645,12 +25044,12 @@ function hasImageGenerationAccess(profileProviderId, profile) {
   if (!scopes) return true;
   return scopes.has("api.model.image.request") || scopes.has("api.model.request") || scopes.has("model.image.request");
 }
-var logger81, IMAGE_CAPABLE_PROVIDERS, ImageGenerationService;
+var logger82, IMAGE_CAPABLE_PROVIDERS, ImageGenerationService;
 var init_image_generation_service = __esm({
   "src/gateway/services/image-generation-service.ts"() {
     "use strict";
     init_src();
-    logger81 = createLogger("image-generation-service");
+    logger82 = createLogger("image-generation-service");
     IMAGE_CAPABLE_PROVIDERS = [
       {
         profileProviderId: "chatgpt",
@@ -24685,7 +25084,7 @@ var init_image_generation_service = __esm({
           );
           if (!profile?.credential) continue;
           if (!hasImageGenerationAccess(profileProviderId, profile)) {
-            logger81.info("Skipping provider without image-generation scope", {
+            logger82.info("Skipping provider without image-generation scope", {
               agentId,
               profileProviderId,
               authType: profile.authType
@@ -24715,7 +25114,7 @@ var init_image_generation_service = __esm({
             agentId
           );
         }
-        logger81.info("Generating image", {
+        logger82.info("Generating image", {
           agentId,
           provider: config.provider,
           profileProviderId: config.profileProviderId,
@@ -24734,7 +25133,7 @@ var init_image_generation_service = __esm({
           };
         } catch (error) {
           const errorMessage3 = error instanceof Error ? error.message : String(error);
-          logger81.error("Image generation failed", {
+          logger82.error("Image generation failed", {
             agentId,
             provider: config.provider,
             profileProviderId: config.profileProviderId,
@@ -24748,7 +25147,7 @@ var init_image_generation_service = __esm({
       }
       noProviderError(message, agentId) {
         const availableProviders = IMAGE_CAPABLE_PROVIDERS.map((p) => p.provider);
-        logger81.info(message, { agentId, availableProviders });
+        logger82.info(message, { agentId, availableProviders });
         return { error: message, availableProviders };
       }
       async generateWithOpenAI(prompt, apiKey, options) {
@@ -24837,13 +25236,13 @@ var init_session = __esm({
 });
 
 // src/gateway/services/session-manager.ts
-var logger82, StateAdapterSessionStore, SessionManager;
+var logger83, StateAdapterSessionStore, SessionManager;
 var init_session_manager = __esm({
   "src/gateway/services/session-manager.ts"() {
     "use strict";
     init_src();
     init_session();
-    logger82 = createLogger("session-manager");
+    logger83 = createLogger("session-manager");
     StateAdapterSessionStore = class {
       constructor(conversations) {
         this.conversations = conversations;
@@ -24853,23 +25252,23 @@ var init_session_manager = __esm({
         try {
           return await this.conversations.getSession(sessionKey3);
         } catch (error) {
-          logger82.error(`Failed to get session ${sessionKey3}:`, error);
+          logger83.error(`Failed to get session ${sessionKey3}:`, error);
           return null;
         }
       }
       async set(sessionKey3, session) {
         await this.conversations.setSession(sessionKey3, session);
-        logger82.debug(`Stored session ${sessionKey3}`);
+        logger83.debug(`Stored session ${sessionKey3}`);
       }
       async delete(sessionKey3) {
         await this.conversations.deleteSession(sessionKey3);
-        logger82.debug(`Deleted session ${sessionKey3}`);
+        logger83.debug(`Deleted session ${sessionKey3}`);
       }
       async getByThread(channelId, threadTs) {
         try {
           return await this.conversations.getSessionByThread(channelId, threadTs);
         } catch (error) {
-          logger82.error(
+          logger83.error(
             `Failed to get session by thread ${channelId}:${threadTs}:`,
             error
           );
@@ -24878,7 +25277,7 @@ var init_session_manager = __esm({
       }
       /** Optional cleanup - state adapter TTL handles this automatically */
       async cleanup() {
-        logger82.debug("StateAdapter TTL handles automatic cleanup");
+        logger83.debug("StateAdapter TTL handles automatic cleanup");
         return 0;
       }
     };
@@ -25148,17 +25547,17 @@ data: ${JSON.stringify({ reason })}
 });
 
 // src/gateway/watchers/run-tracker.ts
-var logger83, WatcherRunTracker;
+var logger84, WatcherRunTracker;
 var init_run_tracker = __esm({
   "src/gateway/watchers/run-tracker.ts"() {
     "use strict";
     init_src();
-    logger83 = createLogger("watcher-run-tracker");
+    logger84 = createLogger("watcher-run-tracker");
     WatcherRunTracker = class {
       pending = /* @__PURE__ */ new Map();
       register(handle) {
         if (this.pending.has(handle.messageId)) {
-          logger83.warn(
+          logger84.warn(
             { messageId: handle.messageId, runId: handle.runId },
             "duplicate watcher run registration ignored"
           );
@@ -25173,7 +25572,7 @@ var init_run_tracker = __esm({
         try {
           await handle.onResolve(result);
         } catch (err) {
-          logger83.error(
+          logger84.error(
             { err, messageId, runId: handle.runId },
             "watcher run onResolve callback failed"
           );
@@ -25235,12 +25634,12 @@ function resolveProviderRegistryFromRaw(raw) {
   try {
     rawParsed = JSON.parse(raw);
   } catch {
-    logger84.error("Invalid providers JSON");
+    logger85.error("Invalid providers JSON");
     return null;
   }
   const substituted = raw.replace(/\$\{env:([^}]+)\}/g, (_match, varName) => {
     if (isBlockedEnvSubstitution(varName)) {
-      logger84.warn(`Blocked env substitution for sensitive var: ${varName}`);
+      logger85.warn(`Blocked env substitution for sensitive var: ${varName}`);
       return "";
     }
     return process.env[varName] || "";
@@ -25249,21 +25648,21 @@ function resolveProviderRegistryFromRaw(raw) {
   try {
     parsed = JSON.parse(substituted);
   } catch {
-    logger84.error("Invalid providers JSON after env substitution");
+    logger85.error("Invalid providers JSON after env substitution");
     return null;
   }
   if (!Array.isArray(parsed.providers)) {
-    logger84.error("Invalid providers config: missing 'providers' array");
+    logger85.error("Invalid providers config: missing 'providers' array");
     return null;
   }
   return { raw: rawParsed, resolved: parsed };
 }
-var logger84, ENV_SUBSTITUTION_BLOCKLIST, ProviderRegistryService;
+var logger85, ENV_SUBSTITUTION_BLOCKLIST, ProviderRegistryService;
 var init_provider_registry_service = __esm({
   "src/gateway/services/provider-registry-service.ts"() {
     "use strict";
     init_src();
-    logger84 = createLogger("provider-registry-service");
+    logger85 = createLogger("provider-registry-service");
     ENV_SUBSTITUTION_BLOCKLIST = /* @__PURE__ */ new Set([
       "ENCRYPTION_KEY",
       "DATABASE_URL",
@@ -25285,7 +25684,7 @@ var init_provider_registry_service = __esm({
           const config = { providers: preloadedProviders };
           this.loaded = config;
           this.rawLoaded = config;
-          logger84.info(
+          logger85.info(
             `Loaded ${preloadedProviders.length} bundled provider(s) (injected)`
           );
         }
@@ -25322,7 +25721,7 @@ var init_provider_registry_service = __esm({
           if (this.configUrl.startsWith("http://") || this.configUrl.startsWith("https://")) {
             const response = await fetch(this.configUrl);
             if (!response.ok) {
-              logger84.error(`Failed to fetch providers config: ${response.status}`);
+              logger85.error(`Failed to fetch providers config: ${response.status}`);
               return null;
             }
             raw = await response.text();
@@ -25333,10 +25732,10 @@ var init_provider_registry_service = __esm({
           if (!resolved) return null;
           this.rawLoaded = resolved.raw;
           this.loaded = resolved.resolved;
-          logger84.info(`Loaded ${this.loaded.providers.length} bundled provider(s)`);
+          logger85.info(`Loaded ${this.loaded.providers.length} bundled provider(s)`);
           return this.loaded;
         } catch (error) {
-          logger84.debug("Providers config not available", { error });
+          logger85.debug("Providers config not available", { error });
           return null;
         }
       }
@@ -25348,12 +25747,12 @@ var init_provider_registry_service = __esm({
 function displayName(provider2) {
   return TTS_CAPABLE_PROVIDERS.find((p) => p.ttsProvider === provider2)?.displayName ?? provider2;
 }
-var logger85, TTS_CAPABLE_PROVIDERS, TranscriptionService;
+var logger86, TTS_CAPABLE_PROVIDERS, TranscriptionService;
 var init_transcription_service = __esm({
   "src/gateway/services/transcription-service.ts"() {
     "use strict";
     init_src();
-    logger85 = createLogger("transcription-service");
+    logger86 = createLogger("transcription-service");
     TTS_CAPABLE_PROVIDERS = [
       {
         profileProviderId: "chatgpt",
@@ -25394,7 +25793,7 @@ var init_transcription_service = __esm({
         }
         const attemptErrors = [];
         for (const config of configs) {
-          logger85.info("Transcribing audio", {
+          logger86.info("Transcribing audio", {
             agentId,
             provider: config.provider,
             profileProviderId: config.profileProviderId,
@@ -25407,7 +25806,7 @@ var init_transcription_service = __esm({
               config,
               mimeType
             );
-            logger85.info("Transcription successful", {
+            logger86.info("Transcription successful", {
               agentId,
               provider: config.provider,
               profileProviderId: config.profileProviderId,
@@ -25416,7 +25815,7 @@ var init_transcription_service = __esm({
             return { text, provider: config.provider };
           } catch (error) {
             const errorMessage3 = error instanceof Error ? error.message : String(error);
-            logger85.error("Transcription failed", {
+            logger86.error("Transcription failed", {
               agentId,
               provider: config.provider,
               profileProviderId: config.profileProviderId,
@@ -25484,7 +25883,7 @@ var init_transcription_service = __esm({
         try {
           providerConfigs = await this.providerConfigSource();
         } catch (error) {
-          logger85.warn("Failed to load provider configs for STT", {
+          logger86.warn("Failed to load provider configs for STT", {
             error: error instanceof Error ? error.message : String(error)
           });
           return [];
@@ -25496,7 +25895,7 @@ var init_transcription_service = __esm({
           const sttEnabled = stt ? stt.enabled !== false : compat === "openai";
           if (!sttEnabled) continue;
           if (compat !== "openai") {
-            logger85.warn("Unsupported config-driven STT compatibility", {
+            logger86.warn("Unsupported config-driven STT compatibility", {
               providerId,
               compat
             });
@@ -25507,7 +25906,7 @@ var init_transcription_service = __esm({
             stt?.baseUrl || entry.upstreamBaseUrl
           );
           if (!endpoint) {
-            logger85.warn("Invalid STT endpoint configuration", {
+            logger86.warn("Invalid STT endpoint configuration", {
               providerId,
               transcriptionPath: stt?.transcriptionPath,
               baseUrl: stt?.baseUrl || entry.upstreamBaseUrl
@@ -25546,7 +25945,7 @@ var init_transcription_service = __esm({
         if (!config) {
           return this.noProviderError("No audio provider configured", agentId);
         }
-        logger85.info("Synthesizing audio", {
+        logger86.info("Synthesizing audio", {
           agentId,
           provider: config.provider,
           textLength: text.length,
@@ -25554,7 +25953,7 @@ var init_transcription_service = __esm({
         });
         try {
           const result = await this.synthesizeWithProvider(text, config, options);
-          logger85.info("Synthesis successful", {
+          logger86.info("Synthesis successful", {
             agentId,
             provider: config.provider,
             audioSize: result.audioBuffer.length
@@ -25562,7 +25961,7 @@ var init_transcription_service = __esm({
           return { ...result, provider: config.provider };
         } catch (error) {
           const errorMessage3 = error instanceof Error ? error.message : String(error);
-          logger85.error("Synthesis failed", {
+          logger86.error("Synthesis failed", {
             agentId,
             provider: config.provider,
             error: errorMessage3
@@ -25575,7 +25974,7 @@ var init_transcription_service = __esm({
       }
       noProviderError(message, agentId) {
         const availableProviders = TTS_CAPABLE_PROVIDERS.map((p) => p.ttsProvider);
-        logger85.info(message, { agentId, availableProviders });
+        logger86.info(message, { agentId, availableProviders });
         return { error: message, availableProviders };
       }
       // ==========================================================================
@@ -25828,7 +26227,7 @@ var init_transcription_service = __esm({
 });
 
 // src/gateway/services/core-services.ts
-var logger86, CoreServices;
+var logger87, CoreServices;
 var init_core_services = __esm({
   "src/gateway/services/core-services.ts"() {
     "use strict";
@@ -25884,7 +26283,7 @@ var init_core_services = __esm({
     init_provider_config_resolver();
     init_provider_registry_service();
     init_transcription_service();
-    logger86 = createLogger("core-services");
+    logger87 = createLogger("core-services");
     CoreServices = class {
       constructor(config, options) {
         this.config = config;
@@ -25990,20 +26389,20 @@ var init_core_services = __esm({
        * Initialize all core services in dependency order
        */
       async initialize() {
-        logger86.debug("Initializing core services...");
+        logger87.debug("Initializing core services...");
         await this.initializeQueue();
-        logger86.debug("Queue initialized");
+        logger87.debug("Queue initialized");
         await this.initializeSessionServices();
-        logger86.debug("Session services initialized");
+        logger87.debug("Session services initialized");
         await this.initializeClaudeServices();
-        logger86.debug("Auth & provider services initialized");
+        logger87.debug("Auth & provider services initialized");
         await this.initializeMcpServices();
-        logger86.debug("MCP services initialized");
+        logger87.debug("MCP services initialized");
         await this.initializeQueueProducer();
-        logger86.debug("Queue producer initialized");
+        logger87.debug("Queue producer initialized");
         this.initializeCommandRegistry();
-        logger86.debug("Command registry initialized");
-        logger86.info("Core services initialized successfully");
+        logger87.debug("Command registry initialized");
+        logger87.info("Core services initialized successfully");
       }
       /** Public entry point for the scheduler-registered ephemeral-table sweep.
        *  Deletes expired rows from oauth_states, rate_limits, grants, and
@@ -26020,13 +26419,13 @@ var init_core_services = __esm({
           ]);
           const pendingInteractions = pendingIds.length;
           if (oauthStates + rate + grants + completedRuns + pendingInteractions > 0) {
-            logger86.debug(
+            logger87.debug(
               { oauthStates, rate, grants, completedRuns, pendingInteractions },
               "Ephemeral table sweeper deleted expired rows"
             );
           }
         } catch (error) {
-          logger86.warn(
+          logger87.warn(
             { error: error instanceof Error ? error.message : String(error) },
             "Ephemeral table sweeper failed"
           );
@@ -26038,7 +26437,7 @@ var init_core_services = __esm({
       async initializeQueue() {
         this.queue = new RunsQueue();
         await this.queue.start();
-        logger86.debug("Queue connection established (runs-table substrate)");
+        logger87.debug("Queue connection established (runs-table substrate)");
       }
       async initializeQueueProducer() {
         if (!this.queue) {
@@ -26046,7 +26445,7 @@ var init_core_services = __esm({
         }
         this.queueProducer = new QueueProducer(this.queue);
         await this.queueProducer.start();
-        logger86.debug("Queue producer initialized");
+        logger87.debug("Queue producer initialized");
       }
       // ============================================================================
       // 2. Session Services Initialization
@@ -26061,17 +26460,17 @@ var init_core_services = __esm({
           new ConversationStateStore(stateAdapter)
         );
         this.sessionManager = new SessionManager(sessionStore);
-        logger86.debug("Session manager initialized");
+        logger87.debug("Session manager initialized");
         this.interactionService = new InteractionService();
-        logger86.debug("Interaction service initialized");
+        logger87.debug("Interaction service initialized");
         this.sseManager = new SseManager();
-        logger86.debug("SSE manager initialized");
+        logger87.debug("SSE manager initialized");
         this.watcherRunTracker = new WatcherRunTracker();
-        logger86.debug("Watcher run tracker initialized");
+        logger87.debug("Watcher run tracker initialized");
         this.grantStore = new GrantStore();
-        logger86.debug("Grant store initialized");
+        logger87.debug("Grant store initialized");
         this.policyStore = new PolicyStore();
-        logger86.debug("Policy store initialized");
+        logger87.debug("Policy store initialized");
         const defaultSecretStore = new PostgresSecretStore();
         this.secretStore = this.options?.secretStore ?? new SecretStoreRegistry(
           defaultSecretStore,
@@ -26084,7 +26483,7 @@ var init_core_services = __esm({
             }
           }
         );
-        logger86.debug("Secret store initialized");
+        logger87.debug("Secret store initialized");
         this.channelBindingService = new ChannelBindingService();
         this.userAgentsStore = new UserAgentsStore();
         if (!this.configStore || !this.connectionStore || !this.accessStore) {
@@ -26097,7 +26496,7 @@ var init_core_services = __esm({
               inMemoryStore,
               this.config.agents
             );
-            logger86.debug(
+            logger87.debug(
               `Agent sub-stores initialized (in-memory, ${this.config.agents.length} agent(s) from config)`
             );
           } else {
@@ -26106,11 +26505,11 @@ var init_core_services = __esm({
             );
           }
         } else {
-          logger86.debug("Using host-provided agent sub-stores (embedded mode)");
+          logger87.debug("Using host-provided agent sub-stores (embedded mode)");
         }
         this.agentSettingsStore = new AgentSettingsStore(this.configStore);
         this.agentMetadataStore = new AgentMetadataStore(this.configStore);
-        logger86.debug(
+        logger87.debug(
           "Agent settings, channel binding, user agents & metadata stores initialized"
         );
         const externalAuthKv = /* @__PURE__ */ new Map();
@@ -26136,7 +26535,7 @@ var init_core_services = __esm({
           }
         }) ?? void 0;
         if (this.externalAuthClient) {
-          logger86.debug("External OAuth client initialized");
+          logger87.debug("External OAuth client initialized");
         }
       }
       // ============================================================================
@@ -26197,7 +26596,7 @@ var init_core_services = __esm({
             }
           }
         }
-        logger86.debug(
+        logger87.debug(
           "Auth profile, model preference, transcription, and image generation services initialized"
         );
         this.secretProxy = new SecretProxy(
@@ -26206,7 +26605,7 @@ var init_core_services = __esm({
           },
           this.secretStore
         );
-        logger86.debug(
+        logger87.debug(
           `Secret proxy initialized (upstream: ${this.config.anthropicProxy.anthropicBaseUrl || "https://api.anthropic.com"})`
         );
         if (!this.authProfilesManager) {
@@ -26217,24 +26616,24 @@ var init_core_services = __esm({
         this.tokenRefreshJob = new TokenRefreshJob(this.authProfilesManager, [
           { providerId: "claude", oauthClient: new OAuthClient(CLAUDE_PROVIDER) }
         ]);
-        logger86.debug("Token refresh job constructed");
+        logger87.debug("Token refresh job constructed");
         this.oauthStateStore = createOAuthStateStore("claude");
         const claudeOAuthModule = new ClaudeOAuthModule(
           this.authProfilesManager,
           this.modelPreferenceStore
         );
         moduleRegistry.register(claudeOAuthModule);
-        logger86.debug(
+        logger87.debug(
           `Claude OAuth module registered (system token: ${claudeOAuthModule.hasSystemKey() ? "available" : "not available"})`
         );
         const chatgptOAuthModule = new ChatGPTOAuthModule(this.authProfilesManager);
         moduleRegistry.register(chatgptOAuthModule);
-        logger86.debug(
+        logger87.debug(
           `ChatGPT OAuth module registered (system token: ${chatgptOAuthModule.hasSystemKey() ? "available" : "not available"})`
         );
         const geminiCliModule = new GeminiCliModule(this.authProfilesManager);
         moduleRegistry.register(geminiCliModule);
-        logger86.debug("Gemini CLI module registered (acpx sub-agent shell-out)");
+        logger87.debug("Gemini CLI module registered (acpx sub-agent shell-out)");
         const bedrockModelCatalog = new BedrockModelCatalog();
         const bedrockProviderModule = new BedrockProviderModule(
           this.authProfilesManager,
@@ -26244,23 +26643,23 @@ var init_core_services = __esm({
         this.bedrockOpenAIService = new BedrockOpenAIService({
           modelCatalog: bedrockModelCatalog
         });
-        logger86.debug("Bedrock provider module registered");
+        logger87.debug("Bedrock provider module registered");
         const injectedProviders = this.options?.providerRegistry;
         if (injectedProviders) {
           this.providerRegistryService = new ProviderRegistryService(
             void 0,
             injectedProviders
           );
-          logger86.debug(
+          logger87.debug(
             `Provider registry initialized from injected providers (${injectedProviders.length})`
           );
         } else {
           const registryPath = resolveProviderRegistryPath();
           this.providerRegistryService = new ProviderRegistryService(registryPath);
           if (registryPath) {
-            logger86.info(`Provider registry path: ${registryPath}`);
+            logger87.info(`Provider registry path: ${registryPath}`);
           } else {
-            logger86.warn(
+            logger87.warn(
               "No providers registry found (set LOBU_PROVIDER_REGISTRY_PATH or run from a dir with config/providers.json) \u2014 config-driven providers will be unavailable"
             );
           }
@@ -26272,7 +26671,7 @@ var init_core_services = __esm({
           () => this.providerConfigResolver ? this.providerConfigResolver.getProviderConfigs() : Promise.resolve({})
         );
         const configProviders = await this.providerConfigResolver.getProviderConfigs();
-        logger86.info(
+        logger87.info(
           `Provider registry loaded ${Object.keys(configProviders).length} config-driven provider(s)`
         );
         const registeredIds = new Set(
@@ -26280,7 +26679,7 @@ var init_core_services = __esm({
         );
         for (const [id, entry] of Object.entries(configProviders)) {
           if (registeredIds.has(id)) {
-            logger86.info(
+            logger87.info(
               `Skipping config-driven provider "${id}" \u2014 already registered`
             );
             continue;
@@ -26302,7 +26701,7 @@ var init_core_services = __esm({
           });
           moduleRegistry.register(module);
           registeredIds.add(id);
-          logger86.debug(
+          logger87.debug(
             `Registered config-driven provider: ${id} (system key: ${module.hasSystemKey() ? "available" : "not available"})`
           );
         }
@@ -26311,7 +26710,7 @@ var init_core_services = __esm({
           this.authProfilesManager,
           this.declaredAgentRegistry
         );
-        logger86.debug("Provider catalog service initialized");
+        logger87.debug("Provider catalog service initialized");
         if (this.secretProxy) {
           this.secretProxy.setAuthProfilesManager(this.authProfilesManager);
           this.secretProxy.setAgentOrgResolver(
@@ -26334,7 +26733,7 @@ var init_core_services = __esm({
             }
             return testEnv[mod.getCredentialEnvVarName()] || void 0;
           });
-          logger86.debug("Provider upstreams registered with secret proxy");
+          logger87.debug("Provider upstreams registered with secret proxy");
         }
       }
       // ============================================================================
@@ -26366,7 +26765,7 @@ var init_core_services = __esm({
           this.mcpConfigService,
           this.agentSettingsStore
         );
-        logger86.debug("Instruction service initialized");
+        logger87.debug("Instruction service initialized");
         if (!this.secretStore) {
           throw new Error("Secret store must be initialized before MCP proxy");
         }
@@ -26417,7 +26816,7 @@ var init_core_services = __esm({
             payload.message
           );
         };
-        logger86.debug("MCP proxy initialized");
+        logger87.debug("MCP proxy initialized");
         this.workerGateway = new WorkerGateway(
           this.queue,
           this.config.mcp.publicGatewayUrl,
@@ -26428,10 +26827,10 @@ var init_core_services = __esm({
           this.agentSettingsStore,
           this.secretStore
         );
-        logger86.debug("Worker gateway initialized");
+        logger87.debug("Worker gateway initialized");
         await moduleRegistry.registerAvailableModules();
         await moduleRegistry.initAll();
-        logger86.debug("Modules initialized");
+        logger87.debug("Modules initialized");
       }
       // ============================================================================
       // 7. Command Registry Initialization
@@ -26446,7 +26845,7 @@ var init_core_services = __esm({
         registerBuiltInCommands(this.commandRegistry, {
           agentSettingsStore: this.agentSettingsStore
         });
-        logger86.debug("Command registry initialized with built-in commands");
+        logger87.debug("Command registry initialized with built-in commands");
       }
       // ============================================================================
       // SDK-Embedded Helpers
@@ -26474,18 +26873,18 @@ var init_core_services = __esm({
       // Shutdown
       // ============================================================================
       async shutdown() {
-        logger86.info("Shutting down core services...");
+        logger87.info("Shutting down core services...");
         if (this.queueProducer) {
           await this.queueProducer.stop();
         }
         if (this.workerGateway) {
           this.workerGateway.shutdown();
-          logger86.info("Worker gateway shutdown complete");
+          logger87.info("Worker gateway shutdown complete");
         }
         if (this.queue) {
           await this.queue.stop();
         }
-        logger86.info("Core services shutdown complete");
+        logger87.info("Core services shutdown complete");
       }
       // ============================================================================
       // Service Accessors (implements ICoreServices interface)
@@ -26637,7 +27036,7 @@ var init_core_services = __esm({
 });
 
 // src/gateway/gateway-main.ts
-var logger87, Gateway;
+var logger88, Gateway;
 var init_gateway_main = __esm({
   "src/gateway/gateway-main.ts"() {
     "use strict";
@@ -26645,7 +27044,7 @@ var init_gateway_main = __esm({
     init_platform2();
     init_unified_thread_consumer();
     init_core_services();
-    logger87 = createLogger("gateway");
+    logger88 = createLogger("gateway");
     Gateway = class {
       constructor(config, options) {
         this.config = config;
@@ -26682,7 +27081,7 @@ var init_gateway_main = __esm({
             this.coreServices.getInstructionService()?.registerPlatformProvider(platform.name, provider2);
           }
         }
-        logger87.debug(`Platform registered: ${platform.name}`);
+        logger88.debug(`Platform registered: ${platform.name}`);
         return this;
       }
       /**
@@ -26693,10 +27092,10 @@ var init_gateway_main = __esm({
        * 4. Start all platforms
        */
       async start() {
-        logger87.debug("Starting gateway...");
+        logger88.debug("Starting gateway...");
         await this.coreServices.initialize();
         for (const [name, platform] of this.platforms) {
-          logger87.debug(`Initializing platform: ${name}`);
+          logger88.debug(`Initializing platform: ${name}`);
           await platform.initialize(this.coreServices);
         }
         const instructionService = this.coreServices.getInstructionService();
@@ -26711,7 +27110,7 @@ var init_gateway_main = __esm({
           }
         }
         for (const [name, platform] of this.platforms) {
-          logger87.debug(`Starting platform: ${name}`);
+          logger88.debug(`Starting platform: ${name}`);
           await platform.start();
         }
         this.unifiedConsumer = new UnifiedThreadResponseConsumer(
@@ -26729,26 +27128,26 @@ var init_gateway_main = __esm({
        * 3. Shutdown core services
        */
       async stop() {
-        logger87.info("Stopping gateway...");
+        logger88.info("Stopping gateway...");
         if (this.unifiedConsumer) {
-          logger87.info("Stopping unified thread response consumer");
+          logger88.info("Stopping unified thread response consumer");
           try {
             await this.unifiedConsumer.stop();
           } catch (error) {
-            logger87.error("Failed to stop unified consumer:", error);
+            logger88.error("Failed to stop unified consumer:", error);
           }
         }
         for (const [name, platform] of this.platforms) {
-          logger87.info(`Stopping platform: ${name}`);
+          logger88.info(`Stopping platform: ${name}`);
           try {
             await platform.stop();
           } catch (error) {
-            logger87.error(`Failed to stop platform ${name}:`, error);
+            logger88.error(`Failed to stop platform ${name}:`, error);
           }
         }
         await this.coreServices.shutdown();
         this.isRunning = false;
-        logger87.info("\u2705 Gateway stopped");
+        logger88.info("\u2705 Gateway stopped");
       }
       /**
        * Get gateway status
@@ -26813,7 +27212,7 @@ function isSecretEnvVar(name, providerModules) {
   const upper = name.toUpperCase();
   return upper.includes("_KEY") || upper.includes("_TOKEN") || upper.includes("_SECRET") || upper.includes("_PASSWORD");
 }
-var logger88, SECRET_PLACEHOLDER_TTL_SECONDS, GRANT_SYNC_CACHE_MAX, BaseDeploymentManager;
+var logger89, SECRET_PLACEHOLDER_TTL_SECONDS, GRANT_SYNC_CACHE_MAX, BaseDeploymentManager;
 var init_base_deployment_manager = __esm({
   "src/gateway/orchestration/base-deployment-manager.ts"() {
     "use strict";
@@ -26821,7 +27220,7 @@ var init_base_deployment_manager = __esm({
     init_policy_store();
     init_secret_proxy();
     init_secrets();
-    logger88 = createLogger("orchestrator");
+    logger89 = createLogger("orchestrator");
     SECRET_PLACEHOLDER_TTL_SECONDS = (() => {
       const raw = process.env.SECRET_PLACEHOLDER_TTL_MS;
       if (raw) {
@@ -26930,7 +27329,7 @@ var init_base_deployment_manager = __esm({
         };
         const deploymentName = generateDeploymentName(deploymentIdentity);
         const canonicalConversationKey = buildCanonicalConversationKey(deploymentIdentity);
-        logger88.info(
+        logger89.info(
           `Worker deployment - conversationId: ${conversationId}, canonicalKey: ${canonicalConversationKey}, deploymentName: ${deploymentName}`
         );
         try {
@@ -26943,14 +27342,14 @@ var init_base_deployment_manager = __esm({
               await this.scaleDeployment(deploymentName, 1);
               return;
             } catch (scaleErr) {
-              logger88.warn(
+              logger89.warn(
                 `scaleDeployment(${deploymentName}, 1) failed (${scaleErr instanceof Error ? scaleErr.message : String(scaleErr)}); re-spawning`
               );
             }
           }
           const maxDeployments = this.config.worker.maxDeployments;
           if (maxDeployments > 0 && deployments.length >= maxDeployments) {
-            logger88.warn(
+            logger89.warn(
               `\u26A0\uFE0F  Maximum deployments limit reached (${deployments.length}/${maxDeployments}). Running cleanup before creating new deployment.`
             );
             await this.reconcileDeployments();
@@ -27014,7 +27413,7 @@ var init_base_deployment_manager = __esm({
         const organizationId = messageData.organizationId;
         if (!this.policyStore || !agentId || !organizationId) {
           if (!organizationId && agentId) {
-            logger88.warn(
+            logger89.warn(
               { agentId, deploymentName },
               "Skipping egress policy sync \u2014 message has no organizationId"
             );
@@ -27029,11 +27428,11 @@ var init_base_deployment_manager = __esm({
         if (bundle) {
           this.policyStore.set(organizationId, agentId, bundle);
           if (deploymentName) {
-            logger88.info(
+            logger89.info(
               `Synced egress judge policy for ${deploymentName}: ${bundle.judgedDomains.length} rule(s), ${Object.keys(bundle.judges).length} judge(s)`
             );
           } else {
-            logger88.debug("Synced egress judge policy", {
+            logger89.debug("Synced egress judge policy", {
               organizationId,
               agentId,
               rules: bundle.judgedDomains.length,
@@ -27056,7 +27455,7 @@ var init_base_deployment_manager = __esm({
           for (const domain of messageData.networkConfig.allowedDomains) {
             await this.grantStore.grant(agentId, domain, null, void 0, orgId);
           }
-          logger88.info(
+          logger89.info(
             `Synced network config domains as grants for ${deploymentName}: ${messageData.networkConfig.allowedDomains.join(", ")}`
           );
         }
@@ -27064,7 +27463,7 @@ var init_base_deployment_manager = __esm({
           for (const pattern of messageData.preApprovedTools) {
             await this.grantStore.grant(agentId, pattern, null, void 0, orgId);
           }
-          logger88.info(
+          logger89.info(
             `Synced pre-approved tool patterns as grants for ${deploymentName}: ${messageData.preApprovedTools.join(", ")}`
           );
         }
@@ -27078,7 +27477,7 @@ var init_base_deployment_manager = __esm({
           for (const domain of NIX_DOMAINS) {
             await this.grantStore.grant(agentId, domain, null, void 0, orgId);
           }
-          logger88.info(
+          logger89.info(
             `Added Nix cache domains as grants for ${deploymentName}: ${NIX_DOMAINS.join(", ")}`
           );
         }
@@ -27217,7 +27616,7 @@ var init_base_deployment_manager = __esm({
           if (flakeUrl) envVars.NIX_FLAKE_URL = flakeUrl;
           if (packages && packages.length > 0)
             envVars.NIX_PACKAGES = packages.join(",");
-          logger88.debug(
+          logger89.debug(
             `Nix config for ${deploymentName}: flakeUrl=${flakeUrl || "none"}, packages=${packages?.length || 0}`
           );
         }
@@ -27280,12 +27679,12 @@ var init_base_deployment_manager = __esm({
               envVars[key] = placeholder;
               hasSecrets = true;
             } catch (error) {
-              logger88.warn(`Failed to generate placeholder for ${key}:`, error);
+              logger89.warn(`Failed to generate placeholder for ${key}:`, error);
             }
           }
         }
         if (hasSecrets) {
-          logger88.info(
+          logger89.info(
             `\u{1F510} Generated secret placeholders for ${deploymentName}, routing through proxy`
           );
         }
@@ -27348,7 +27747,7 @@ var init_base_deployment_manager = __esm({
               providerContext
             );
           } catch (error) {
-            logger88.warn("Failed to build module environment variables:", error);
+            logger89.warn("Failed to build module environment variables:", error);
           }
         }
         if (this.config.worker.env) {
@@ -27383,7 +27782,7 @@ var init_base_deployment_manager = __esm({
           }
         }
         if (primaryProvider) {
-          logger88.info(
+          logger89.info(
             {
               agentId,
               primaryProviderId: primaryProvider.providerId,
@@ -27429,7 +27828,7 @@ var init_base_deployment_manager = __esm({
           for (const domain of NPM_DOMAINS) {
             await this.grantStore.grant(agentId, domain, null, void 0, orgId);
           }
-          logger88.info(
+          logger89.info(
             `Added npm registry domains as grants for ${deploymentName}: ${NPM_DOMAINS.join(", ")}`
           );
         }
@@ -27448,12 +27847,12 @@ var init_base_deployment_manager = __esm({
                 `deployments/${deploymentName}/`
               );
               if (cleared > 0) {
-                logger88.debug(
+                logger89.debug(
                   `Cleared ${cleared} deployment secret(s) for ${deploymentName}`
                 );
               }
             } catch (error) {
-              logger88.warn(
+              logger89.warn(
                 `Failed to clear deployment secrets for ${deploymentName}:`,
                 error
               );
@@ -27476,7 +27875,7 @@ var init_base_deployment_manager = __esm({
       async reconcileDeployments() {
         try {
           const maxDeployments = this.config.worker.maxDeployments;
-          logger88.debug("Running deployment cleanup...");
+          logger89.debug("Running deployment cleanup...");
           const activeDeployments = await this.listDeployments();
           if (activeDeployments.length === 0) {
             return;
@@ -27517,7 +27916,7 @@ var init_base_deployment_manager = __esm({
               if (results[j]?.status === "fulfilled") {
                 processedCount++;
               } else {
-                logger88.error(
+                logger89.error(
                   `\u274C Failed to delete deployment ${batch[j]}:`,
                   results[j].reason
                 );
@@ -27533,7 +27932,7 @@ var init_base_deployment_manager = __esm({
               if (results[j]?.status === "fulfilled") {
                 processedCount++;
               } else {
-                logger88.error(
+                logger89.error(
                   `\u274C Failed to scale down deployment ${batch[j]}:`,
                   results[j].reason
                 );
@@ -27541,12 +27940,12 @@ var init_base_deployment_manager = __esm({
             }
           }
           if (processedCount > 0) {
-            logger88.info(
+            logger89.info(
               `\u2705 Cleanup completed: processed ${processedCount} deployment(s)`
             );
           }
         } catch (error) {
-          logger88.error(
+          logger89.error(
             "Error during deployment reconciliation:",
             error instanceof Error ? error.message : String(error)
           );
@@ -27668,6 +28067,111 @@ function makeUnitName(deploymentName) {
   const tag = Math.random().toString(36).slice(2, 8);
   return `lobu-worker-${safe}-${tag}`;
 }
+function getDefaultMaxReservedLocks() {
+  const poolMax = Number.parseInt(process.env.DB_POOL_MAX || "20", 10);
+  if (!Number.isFinite(poolMax) || poolMax <= 0) {
+    return Math.max(1, 20 - POOL_HEADROOM);
+  }
+  return Math.max(1, poolMax - POOL_HEADROOM);
+}
+function getMaxReservedLocks() {
+  const raw = process.env.LOBU_MAX_RESERVED_LOCKS;
+  if (!raw) return getDefaultMaxReservedLocks();
+  const n = Number.parseInt(raw, 10);
+  if (!Number.isFinite(n) || n < 0) return getDefaultMaxReservedLocks();
+  return n;
+}
+function getReservedLockCount() {
+  return reservedLockCount;
+}
+async function acquireConversationLock(organizationId, agentId, conversationId) {
+  if (process.env.LOBU_DISABLE_PREPARE === "1") {
+    return { release: async () => {
+    } };
+  }
+  const max = getMaxReservedLocks();
+  if (reservedLockCount >= max) {
+    logger90.warn(
+      `Reserved-lock cap reached (${reservedLockCount}/${max}); deferring spawn for ${organizationId}/${agentId}/${conversationId}`
+    );
+    return null;
+  }
+  reservedLockCount += 1;
+  if (!warnedNearCap && reservedLockCount >= Math.ceil(max * 0.8)) {
+    logger90.warn(
+      `Reserved-lock count near cap: ${reservedLockCount}/${max}. Tune via LOBU_MAX_RESERVED_LOCKS or scale pods.`
+    );
+    warnedNearCap = true;
+  }
+  let decremented = false;
+  const decrementOnce = () => {
+    if (decremented) return;
+    decremented = true;
+    reservedLockCount = Math.max(0, reservedLockCount - 1);
+    if (warnedNearCap && reservedLockCount < Math.ceil(max * 0.8)) {
+      warnedNearCap = false;
+    }
+  };
+  const sql = getDb();
+  let reserved;
+  try {
+    reserved = await sql.reserve();
+  } catch (err) {
+    decrementOnce();
+    throw err;
+  }
+  const key2 = hashConvKey2(organizationId, agentId, conversationId);
+  try {
+    const rows = await reserved`SELECT pg_try_advisory_lock(${CONV_LOCK_KEY1}, ${key2}) AS acquired`;
+    if (!rows[0]?.acquired) {
+      reserved.release();
+      decrementOnce();
+      return null;
+    }
+  } catch (err) {
+    reserved.release();
+    decrementOnce();
+    throw err;
+  }
+  return {
+    async release() {
+      const MAX_ATTEMPTS = 3;
+      const BACKOFF_MS = 100;
+      let lastErr = null;
+      for (let attempt = 1; attempt <= MAX_ATTEMPTS; attempt++) {
+        try {
+          await reserved`SELECT pg_advisory_unlock(${CONV_LOCK_KEY1}, ${key2})`;
+          lastErr = null;
+          break;
+        } catch (err) {
+          lastErr = err;
+          if (attempt < MAX_ATTEMPTS) {
+            await new Promise((r) => setTimeout(r, BACKOFF_MS * attempt));
+          }
+        }
+      }
+      if (lastErr) {
+        logger90.error(
+          `Failed to release advisory lock after ${MAX_ATTEMPTS} attempts for ${organizationId}/${agentId}/${conversationId}: ${lastErr instanceof Error ? lastErr.message : String(lastErr)}`
+        );
+      }
+      try {
+        reserved.release();
+      } catch {
+      }
+      decrementOnce();
+    }
+  };
+}
+function hashConvKey2(organizationId, agentId, conversationId) {
+  const input = `${organizationId}:${agentId}:${conversationId}`;
+  let hash = 2166136261;
+  for (let i = 0; i < input.length; i++) {
+    hash ^= input.charCodeAt(i);
+    hash = hash + ((hash << 1) + (hash << 4) + (hash << 7) + (hash << 8) + (hash << 24)) | 0;
+  }
+  return hash;
+}
 function buildEmbeddedWorkerPath(binPathEntries, existingPath) {
   const segments = (existingPath || "").split(":").filter(Boolean);
   for (const candidate of [...binPathEntries ?? []].reverse()) {
@@ -27724,15 +28228,20 @@ function nixPackageAttrRef(pkg) {
   }
   return `pkgs.${namespace}.${leaf}`;
 }
-var logger89, KILL_TIMEOUT_MS, cachedSystemdRun, NIX_PACKAGE_NAMESPACES, NIX_LEAF_RE, NIX_ATTR_LEAF_RE, EmbeddedDeploymentManager;
+var logger90, KILL_TIMEOUT_MS, cachedSystemdRun, CONV_LOCK_KEY1, POOL_HEADROOM, reservedLockCount, warnedNearCap, NIX_PACKAGE_NAMESPACES, NIX_LEAF_RE, NIX_ATTR_LEAF_RE, EmbeddedDeploymentManager;
 var init_embedded_deployment = __esm({
   "src/gateway/orchestration/impl/embedded-deployment.ts"() {
     "use strict";
     init_src();
+    init_client();
     init_base_deployment_manager();
     init_deployment_utils();
-    logger89 = createLogger("orchestrator");
+    logger90 = createLogger("orchestrator");
     KILL_TIMEOUT_MS = 5e3;
+    CONV_LOCK_KEY1 = 1819239029;
+    POOL_HEADROOM = 5;
+    reservedLockCount = 0;
+    warnedNearCap = false;
     NIX_PACKAGE_NAMESPACES = /* @__PURE__ */ new Set([
       "python3Packages",
       "python311Packages",
@@ -27784,7 +28293,7 @@ var init_embedded_deployment = __esm({
             `Worker entry point not found: ${entryPoint}`
           );
         }
-        logger89.debug(`Worker entry point verified: ${entryPoint}`);
+        logger90.debug(`Worker entry point verified: ${entryPoint}`);
       }
       async spawnDeployment(deploymentName, username, userId, messageData) {
         if (this.workers.has(deploymentName)) {
@@ -27805,111 +28314,164 @@ var init_embedded_deployment = __esm({
         }
         const workspaceDir = path5.resolve(`workspaces/${agentId}`);
         fs2.mkdirSync(workspaceDir, { recursive: true, mode: 448 });
-        const commonEnvVars = await this.generateEnvironmentVariables(
-          username,
-          userId,
-          deploymentName,
-          messageData,
-          true
-        );
-        commonEnvVars.WORKSPACE_DIR = workspaceDir;
-        const embeddedPath = buildEmbeddedWorkerPath(
-          this.config.worker.binPathEntries,
-          commonEnvVars.PATH || process.env.PATH
-        );
-        if (embeddedPath) {
-          commonEnvVars.PATH = embeddedPath;
-        }
-        const allowedDomains = messageData?.networkConfig?.allowedDomains ?? [];
-        if (allowedDomains.length > 0) {
-          commonEnvVars.JUST_BASH_ALLOWED_DOMAINS = JSON.stringify(allowedDomains);
-        }
-        const nixPackages = messageData?.nixConfig?.packages ?? [];
-        const workerEntryPoint = this.getWorkerEntryPoint();
-        const workerInvocation = buildWorkerInvocation(workerEntryPoint);
-        let command;
-        let spawnArgs;
-        if (nixPackages.length > 0) {
-          const packageRefs = nixPackages.map(nixPackageAttrRef);
-          command = "nix-shell";
-          spawnArgs = [
-            "-E",
-            `let pkgs = import <nixpkgs> {}; in pkgs.mkShell { buildInputs = [ ${packageRefs.join(" ")} ]; }`,
-            "--run",
-            buildShellCommand(workerInvocation.command, workerInvocation.args)
-          ];
-          logger89.info(
-            `Spawning embedded worker ${deploymentName} with nix packages: ${nixPackages.join(", ")}`
+        const snapshotModeEnabled = process.env.LOBU_SESSION_STORE !== "file";
+        const conversationId = typeof messageData?.conversationId === "string" ? messageData.conversationId : null;
+        const organizationId = typeof messageData?.organizationId === "string" ? messageData.organizationId : null;
+        let convLock = null;
+        if (snapshotModeEnabled && organizationId && conversationId) {
+          try {
+            convLock = await acquireConversationLock(
+              organizationId,
+              agentId,
+              conversationId
+            );
+          } catch (err) {
+            logger90.error(
+              `Failed to acquire conversation lock: ${err instanceof Error ? err.message : String(err)}`
+            );
+            throw new OrchestratorError(
+              "DEPLOYMENT_CREATE_FAILED" /* DEPLOYMENT_CREATE_FAILED */,
+              "Could not acquire per-conversation lock"
+            );
+          }
+          if (!convLock) {
+            logger90.info(
+              `Conversation lock busy for ${organizationId}/${agentId}/${conversationId}; deferring spawn`
+            );
+            throw new OrchestratorError(
+              "DEPLOYMENT_CREATE_FAILED" /* DEPLOYMENT_CREATE_FAILED */,
+              "Conversation lock busy on another pod"
+            );
+          }
+        }
+        let child;
+        let commonEnvVars;
+        try {
+          commonEnvVars = await this.generateEnvironmentVariables(
+            username,
+            userId,
+            deploymentName,
+            messageData,
+            true
           );
-        } else {
-          command = workerInvocation.command;
-          spawnArgs = workerInvocation.args;
-        }
-        const systemdRun = locateSystemdRun();
-        if (systemdRun) {
-          const unitName = makeUnitName(deploymentName);
-          const innerCommand = command;
-          const innerArgs = spawnArgs;
-          command = systemdRun;
-          spawnArgs = [
-            ...buildSystemdRunArgs({ unitName, workspaceDir }),
-            "--",
-            innerCommand,
-            ...innerArgs
-          ];
-          logger89.info(
-            `Spawning embedded worker ${deploymentName} under systemd-run scope ${unitName}`
+          commonEnvVars.WORKSPACE_DIR = workspaceDir;
+          if (!snapshotModeEnabled) {
+            commonEnvVars.LOBU_SESSION_STORE = "file";
+          }
+          const embeddedPath = buildEmbeddedWorkerPath(
+            this.config.worker.binPathEntries,
+            commonEnvVars.PATH || process.env.PATH
           );
+          if (embeddedPath) {
+            commonEnvVars.PATH = embeddedPath;
+          }
+          const allowedDomains = messageData?.networkConfig?.allowedDomains ?? [];
+          if (allowedDomains.length > 0) {
+            commonEnvVars.JUST_BASH_ALLOWED_DOMAINS = JSON.stringify(allowedDomains);
+          }
+          const nixPackages = messageData?.nixConfig?.packages ?? [];
+          const workerEntryPoint = this.getWorkerEntryPoint();
+          const workerInvocation = buildWorkerInvocation(workerEntryPoint);
+          let command;
+          let spawnArgs;
+          if (nixPackages.length > 0) {
+            const packageRefs = nixPackages.map(nixPackageAttrRef);
+            command = "nix-shell";
+            spawnArgs = [
+              "-E",
+              `let pkgs = import <nixpkgs> {}; in pkgs.mkShell { buildInputs = [ ${packageRefs.join(" ")} ]; }`,
+              "--run",
+              buildShellCommand(workerInvocation.command, workerInvocation.args)
+            ];
+            logger90.info(
+              `Spawning embedded worker ${deploymentName} with nix packages: ${nixPackages.join(", ")}`
+            );
+          } else {
+            command = workerInvocation.command;
+            spawnArgs = workerInvocation.args;
+          }
+          const systemdRun = locateSystemdRun();
+          if (systemdRun) {
+            const unitName = makeUnitName(deploymentName);
+            const innerCommand = command;
+            const innerArgs = spawnArgs;
+            command = systemdRun;
+            spawnArgs = [
+              ...buildSystemdRunArgs({ unitName, workspaceDir }),
+              "--",
+              innerCommand,
+              ...innerArgs
+            ];
+            logger90.info(
+              `Spawning embedded worker ${deploymentName} under systemd-run scope ${unitName}`
+            );
+          }
+          child = spawn(command, spawnArgs, {
+            // Workers must not inherit gateway-only secrets or telemetry settings
+            // (DATABASE_URL, SENTRY_DSN, OAuth secrets, etc.). Everything a worker
+            // needs is assembled explicitly above, with optional operator-provided
+            // values forwarded only via WORKER_ENV_*.
+            env: commonEnvVars,
+            cwd: workspaceDir,
+            stdio: ["ignore", "pipe", "pipe"]
+          });
+        } catch (err) {
+          if (convLock) {
+            void convLock.release();
+          }
+          throw err;
         }
-        const child = spawn(command, spawnArgs, {
-          // Workers must not inherit gateway-only secrets or telemetry settings
-          // (DATABASE_URL, SENTRY_DSN, OAuth secrets, etc.). Everything a worker
-          // needs is assembled explicitly above, with optional operator-provided
-          // values forwarded only via WORKER_ENV_*.
-          env: commonEnvVars,
-          cwd: workspaceDir,
-          stdio: ["ignore", "pipe", "pipe"]
-        });
+        let lockReleased = false;
+        const releaseLockOnce = async () => {
+          if (lockReleased) return;
+          lockReleased = true;
+          if (convLock) {
+            await convLock.release();
+          }
+        };
         child.once("error", (err) => {
-          logger89.error(
+          logger90.error(
             `Embedded worker ${deploymentName} spawn error: ${err.message}`
           );
           this.workers.delete(deploymentName);
+          releaseLockOnce();
         });
         child.stdout?.on("data", (data) => {
           for (const line of data.toString().trimEnd().split("\n")) {
-            logger89.info({ worker: deploymentName }, line);
+            logger90.info({ worker: deploymentName }, line);
           }
         });
         child.stderr?.on("data", (data) => {
           for (const line of data.toString().trimEnd().split("\n")) {
-            logger89.warn({ worker: deploymentName }, line);
+            logger90.warn({ worker: deploymentName }, line);
           }
         });
         child.once("exit", (code, signal) => {
-          const entry = this.workers.get(deploymentName);
-          if (entry) {
-            this.workers.delete(deploymentName);
-          }
+          this.workers.delete(deploymentName);
+          releaseLockOnce();
           if (signal) {
-            logger89.info(
+            logger90.info(
               `Embedded worker ${deploymentName} exited with signal ${signal}`
             );
           } else if (code !== 0) {
-            logger89.error(
+            logger90.error(
               `Embedded worker ${deploymentName} exited with code ${code}`
             );
           } else {
-            logger89.info(`Embedded worker ${deploymentName} exited cleanly`);
+            logger90.info(`Embedded worker ${deploymentName} exited cleanly`);
           }
         });
         this.workers.set(deploymentName, {
           process: child,
           env: commonEnvVars,
           lastActivity: /* @__PURE__ */ new Date(),
-          workspaceDir
+          workspaceDir,
+          // Expose the idempotent release on the entry for introspection /
+          // tests. The exit handler is the authoritative release site;
+          // killWorker no longer touches this field.
+          ...convLock ? { releaseConvLock: releaseLockOnce } : {}
         });
-        logger89.info(
+        logger90.info(
           `Started embedded worker subprocess for ${deploymentName} (pid=${child.pid})`
         );
       }
@@ -27917,7 +28479,7 @@ var init_embedded_deployment = __esm({
         const entry = this.workers.get(deploymentName);
         if (replicas === 0 && entry) {
           await this.killWorker(entry, deploymentName);
-          logger89.info(`Stopped embedded worker ${deploymentName}`);
+          logger90.info(`Stopped embedded worker ${deploymentName}`);
         } else if (replicas === 1 && !entry) {
           throw new Error(
             `Embedded worker ${deploymentName} is not running \u2014 must re-create`
@@ -27928,7 +28490,7 @@ var init_embedded_deployment = __esm({
         const entry = this.workers.get(deploymentName);
         if (entry) {
           await this.killWorker(entry, deploymentName);
-          logger89.info(`Stopped embedded worker: ${deploymentName}`);
+          logger90.info(`Stopped embedded worker: ${deploymentName}`);
         }
       }
       async listDeployments() {
@@ -27956,7 +28518,14 @@ var init_embedded_deployment = __esm({
           entry.lastActivity = /* @__PURE__ */ new Date();
         }
       }
-      /** Send SIGTERM, then SIGKILL after timeout. Resolves on child exit. */
+      /** Send SIGTERM, then SIGKILL after timeout. Resolves on child exit.
+       *
+       * Does NOT release the conversation lock — the child's exit handler is
+       * the authoritative release site, and the release call there is
+       * idempotent. Releasing here before `await exited` (as a prior version
+       * did) lets a sibling pod claim the conversation while this worker is
+       * still flushing its cleanup() snapshot. Codex P1#3 on PR #865.
+       */
       async killWorker(entry, deploymentName) {
         const child = entry.process;
         this.workers.delete(deploymentName);
@@ -27967,7 +28536,7 @@ var init_embedded_deployment = __esm({
         child.kill("SIGTERM");
         const killTimer = setTimeout(() => {
           if (child.exitCode === null && child.signalCode === null) {
-            logger89.warn(
+            logger90.warn(
               `Embedded worker ${deploymentName} did not exit after SIGTERM, sending SIGKILL`
             );
             child.kill("SIGKILL");
@@ -27985,14 +28554,14 @@ var init_embedded_deployment = __esm({
 
 // src/gateway/orchestration/message-consumer.ts
 import * as Sentry4 from "@sentry/node";
-var logger90, MessageConsumer;
+var logger91, MessageConsumer;
 var init_message_consumer = __esm({
   "src/gateway/orchestration/message-consumer.ts"() {
     "use strict";
     init_src();
     init_queue();
     init_base_deployment_manager();
-    logger90 = createLogger("orchestrator");
+    logger91 = createLogger("orchestrator");
     MessageConsumer = class {
       queue;
       deploymentManager;
@@ -28016,7 +28585,7 @@ var init_message_consumer = __esm({
           await this.queue.start();
           this.isRunning = true;
           await this.queue.createQueue("messages");
-          logger90.debug("Created/verified messages queue");
+          logger91.debug("Created/verified messages queue");
           await this.queue.work(
             "messages",
             async (job) => {
@@ -28034,7 +28603,7 @@ var init_message_consumer = __esm({
               );
             }
           );
-          logger90.debug("Queue consumer started");
+          logger91.debug("Queue consumer started");
         } catch (error) {
           throw new OrchestratorError(
             "QUEUE_JOB_PROCESSING_FAILED" /* QUEUE_JOB_PROCESSING_FAILED */,
@@ -28064,7 +28633,7 @@ var init_message_consumer = __esm({
           "lobu.conversation_id": data?.conversationId || "unknown"
         });
         const childTraceparent = getTraceparent(queueSpan) || traceparent;
-        logger90.info(
+        logger91.info(
           {
             traceparent,
             traceId,
@@ -28075,6 +28644,10 @@ var init_message_consumer = __esm({
           "Processing job with trace context"
         );
         try {
+          const parsedRunId = Number(jobId);
+          if (Number.isFinite(parsedRunId) && parsedRunId > 0) {
+            data.runId = parsedRunId;
+          }
           const effectiveConversationId = data.conversationId;
           if (!effectiveConversationId) {
             throw new OrchestratorError(
@@ -28095,7 +28668,22 @@ var init_message_consumer = __esm({
             channelId: data.channelId,
             conversationId: effectiveConversationId
           });
-          logger90.info(
+          if (data.runId !== void 0) {
+            data.runJobToken = generateWorkerToken(
+              data.userId,
+              effectiveConversationId,
+              deploymentName,
+              {
+                channelId: data.channelId,
+                teamId: data.teamId,
+                agentId: data.agentId,
+                organizationId: data.organizationId,
+                platform: data.platform,
+                runId: data.runId
+              }
+            );
+          }
+          logger91.info(
             `Conversation routing - effectiveConversationId: ${effectiveConversationId}, canonicalKey: ${canonicalConversationKey}, deploymentName: ${deploymentName}`
           );
           await Sentry4.startSpan(
@@ -28112,7 +28700,7 @@ var init_message_consumer = __esm({
               await this.sendToWorkerQueue(data, deploymentName);
             }
           );
-          logger90.info(
+          logger91.info(
             { traceId, traceparent: childTraceparent, deploymentName },
             "Enqueued message to thread queue"
           );
@@ -28132,7 +28720,7 @@ var init_message_consumer = __esm({
               },
               level: "error"
             });
-            logger90.error(
+            logger91.error(
               {
                 traceId,
                 error: bgError instanceof Error ? bgError.message : String(bgError),
@@ -28145,13 +28733,13 @@ var init_message_consumer = __esm({
             );
             this.trackFailedDeployment(deploymentName, data, bgError).catch(
               (trackError) => {
-                logger90.error("Failed to track deployment failure:", trackError);
+                logger91.error("Failed to track deployment failure:", trackError);
               }
             );
           });
           queueSpan?.setStatus({ code: SpanStatusCode.OK });
           queueSpan?.end();
-          logger90.info({ traceId, jobId }, "Message job queued successfully");
+          logger91.info({ traceId, jobId }, "Message job queued successfully");
         } catch (error) {
           queueSpan?.setStatus({
             code: SpanStatusCode.ERROR,
@@ -28159,7 +28747,7 @@ var init_message_consumer = __esm({
           });
           queueSpan?.end();
           Sentry4.captureException(error);
-          logger90.error({ traceId, jobId, error }, "Message job failed");
+          logger91.error({ traceId, jobId, error }, "Message job failed");
           throw new OrchestratorError(
             "QUEUE_JOB_PROCESSING_FAILED" /* QUEUE_JOB_PROCESSING_FAILED */,
             `Failed to process message job: ${error instanceof Error ? error.message : String(error)}`,
@@ -28191,11 +28779,11 @@ var init_message_consumer = __esm({
               true
             );
           }
-          logger90.info(
+          logger91.info(
             `\u2705 Sent message to thread queue ${threadQueueName} for conversation ${data.conversationId}, jobId: ${jobId}`
           );
         } catch (error) {
-          logger90.error(`\u274C [ERROR] sendToWorkerQueue failed:`, error);
+          logger91.error(`\u274C [ERROR] sendToWorkerQueue failed:`, error);
           throw new OrchestratorError(
             "QUEUE_JOB_PROCESSING_FAILED" /* QUEUE_JOB_PROCESSING_FAILED */,
             `Failed to send message to thread queue: ${error instanceof Error ? error.message : String(error)}`,
@@ -28241,7 +28829,7 @@ var init_message_consumer = __esm({
             if (isNewThread) {
               const acquired = this.acquireDeploymentLock(deploymentName);
               if (!acquired) {
-                logger90.info(
+                logger91.info(
                   { traceId, deploymentName },
                   "Another handler is creating this deployment, waiting"
                 );
@@ -28249,7 +28837,7 @@ var init_message_consumer = __esm({
                 const rechecked = await this.deploymentManager.listDeployments();
                 if (rechecked.some((d) => d.deploymentName === deploymentName)) {
                   await this.deploymentManager.scaleDeployment(deploymentName, 1);
-                  logger90.info(
+                  logger91.info(
                     { traceId, deploymentName },
                     "Deployment created by other handler, scaled up"
                   );
@@ -28263,7 +28851,7 @@ var init_message_consumer = __esm({
               try {
                 const recheckAfterLock = await this.deploymentManager.listDeployments();
                 if (recheckAfterLock.some((d) => d.deploymentName === deploymentName)) {
-                  logger90.info(
+                  logger91.info(
                     { traceId, deploymentName },
                     "Deployment already created by another handler after lock acquired"
                   );
@@ -28273,7 +28861,7 @@ var init_message_consumer = __esm({
                   );
                   return;
                 }
-                logger90.info(
+                logger91.info(
                   { traceId, traceparent, conversationId, deploymentName },
                   "New thread - creating deployment"
                 );
@@ -28283,24 +28871,24 @@ var init_message_consumer = __esm({
                   dataWithTrace,
                   recheckAfterLock
                 );
-                logger90.info({ traceId, deploymentName }, "Created deployment");
+                logger91.info({ traceId, deploymentName }, "Created deployment");
               } finally {
                 this.releaseDeploymentLock(deploymentName);
               }
             } else {
-              logger90.info(
+              logger91.info(
                 { traceId, conversationId, deploymentName },
                 "Existing thread - ensuring worker exists"
               );
               await this.deploymentManager.syncNetworkConfigGrants(dataWithTrace);
               try {
                 await this.deploymentManager.scaleDeployment(deploymentName, 1);
-                logger90.info(
+                logger91.info(
                   { traceId, deploymentName },
                   "Scaled existing worker to 1"
                 );
               } catch {
-                logger90.info(
+                logger91.info(
                   { traceId, conversationId, deploymentName },
                   "Worker doesn't exist, creating it"
                 );
@@ -28309,11 +28897,11 @@ var init_message_consumer = __esm({
                   conversationId,
                   dataWithTrace
                 );
-                logger90.info({ traceId, deploymentName }, "Created worker");
+                logger91.info({ traceId, deploymentName }, "Created worker");
               }
             }
             await this.deploymentManager.updateDeploymentActivity(deploymentName);
-            logger90.info({ traceId, deploymentName }, "Worker is ready");
+            logger91.info({ traceId, deploymentName }, "Worker is ready");
           },
           {
             maxRetries: 3,
@@ -28321,7 +28909,7 @@ var init_message_consumer = __esm({
             strategy: "linear",
             jitter: true,
             onRetry: (attempt, error) => {
-              logger90.warn(
+              logger91.warn(
                 { traceId, deploymentName, attempt, maxAttempts: 3 },
                 `Retry attempt failed: ${error.message}`
               );
@@ -28335,7 +28923,7 @@ var init_message_consumer = __esm({
        */
       async trackFailedDeployment(deploymentName, data, error) {
         try {
-          logger90.error(
+          logger91.error(
             {
               deploymentName,
               userId: data.userId,
@@ -28361,10 +28949,10 @@ var init_message_consumer = __esm({
               processedMessageIds: [data.messageId]
             });
           } catch (notifyError) {
-            logger90.error("Failed to send error notification to user:", notifyError);
+            logger91.error("Failed to send error notification to user:", notifyError);
           }
         } catch (trackError) {
-          logger90.error("Failed to track deployment failure:", trackError);
+          logger91.error("Failed to track deployment failure:", trackError);
         }
       }
       /**
@@ -28378,7 +28966,7 @@ var init_message_consumer = __esm({
             isRunning: this.isRunning
           };
         } catch (error) {
-          logger90.error("Failed to get queue stats:", error);
+          logger91.error("Failed to get queue stats:", error);
           return {
             isRunning: this.isRunning,
             error: error instanceof Error ? error.message : String(error)
@@ -28390,7 +28978,7 @@ var init_message_consumer = __esm({
 });
 
 // src/gateway/orchestration/index.ts
-var logger91, Orchestrator;
+var logger92, Orchestrator;
 var init_orchestration = __esm({
   "src/gateway/orchestration/index.ts"() {
     "use strict";
@@ -28402,7 +28990,7 @@ var init_orchestration = __esm({
     init_deployment_utils();
     init_embedded_deployment();
     init_message_consumer();
-    logger91 = createLogger("orchestrator");
+    logger92 = createLogger("orchestrator");
     Orchestrator = class {
       config;
       deploymentManager;
@@ -28442,7 +29030,7 @@ var init_orchestration = __esm({
         }
         const providerModules = getModelProviderModules();
         this.deploymentManager.setProviderModules(providerModules);
-        logger91.debug(
+        logger92.debug(
           `Provider modules injected into orchestrator (${providerModules.length})`
         );
       }
@@ -28455,9 +29043,9 @@ var init_orchestration = __esm({
           await this.queueConsumer.start();
           this.setupIdleCleanup();
           this.isRunning = true;
-          logger91.debug("Orchestrator started");
+          logger92.debug("Orchestrator started");
         } catch (error) {
-          logger91.error("\u274C Failed to start orchestrator:", error);
+          logger92.error("\u274C Failed to start orchestrator:", error);
           throw error;
         }
       }
@@ -28475,9 +29063,9 @@ var init_orchestration = __esm({
             this.initialReconcileTimer = void 0;
           }
           if (this.activeReconciliation) {
-            logger91.info("Waiting for in-flight reconciliation to complete...");
+            logger92.info("Waiting for in-flight reconciliation to complete...");
             const safeReconciliation = this.activeReconciliation.catch((error) => {
-              logger91.error(
+              logger92.error(
                 "In-flight reconciliation failed during shutdown:",
                 error
               );
@@ -28497,11 +29085,11 @@ var init_orchestration = __esm({
               )
             );
           } catch (error) {
-            logger91.error("Error draining workers during shutdown:", error);
+            logger92.error("Error draining workers during shutdown:", error);
           }
-          logger91.info("\u2705 Orchestrator stopped");
+          logger92.info("\u2705 Orchestrator stopped");
         } catch (error) {
-          logger91.error("\u274C Error stopping orchestrator:", error);
+          logger92.error("\u274C Error stopping orchestrator:", error);
         }
       }
       setupIdleCleanup() {
@@ -28509,7 +29097,7 @@ var init_orchestration = __esm({
           this.initialReconcileTimer = void 0;
           if (this.shuttingDown) return;
           const p = this.deploymentManager.reconcileDeployments().catch((error) => {
-            logger91.error("\u274C Initial deployment reconciliation failed:", error);
+            logger92.error("\u274C Initial deployment reconciliation failed:", error);
           });
           this.activeReconciliation = p;
           p.finally(() => {
@@ -28519,7 +29107,7 @@ var init_orchestration = __esm({
         this.cleanupInterval = setInterval(async () => {
           if (this.shuttingDown) return;
           if (this.isReconciling) {
-            logger91.debug(
+            logger92.debug(
               "Skipping reconciliation interval: previous run still in progress"
             );
             return;
@@ -28530,7 +29118,7 @@ var init_orchestration = __esm({
             this.activeReconciliation = p;
             await p;
           } catch (error) {
-            logger91.error(
+            logger92.error(
               "Error during deployment reconciliation:",
               error instanceof Error ? error.message : String(error)
             );
@@ -28569,20 +29157,20 @@ var init_orchestration = __esm({
 function loadAllowedDomains() {
   const allowedDomains = process.env.WORKER_ALLOWED_DOMAINS;
   if (!allowedDomains) {
-    logger92.warn(
+    logger93.warn(
       "\u26A0\uFE0F  WORKER_ALLOWED_DOMAINS not set - workers will have NO internet access (complete isolation)"
     );
     return [];
   }
   const trimmed = allowedDomains.trim();
   if (trimmed === "*") {
-    logger92.debug("WORKER_ALLOWED_DOMAINS=* - unrestricted internet access");
+    logger93.debug("WORKER_ALLOWED_DOMAINS=* - unrestricted internet access");
     return ["*"];
   }
   const parsed = normalizeDomainPatterns(
     trimmed.split(",").map((d) => d.trim()).filter((d) => d.length > 0)
   ) ?? [];
-  logger92.debug(
+  logger93.debug(
     `Loaded ${parsed.length} allowed domains from WORKER_ALLOWED_DOMAINS`
   );
   return parsed;
@@ -28596,17 +29184,17 @@ function loadDisallowedDomains() {
   const parsed = normalizeDomainPatterns(
     disallowedDomains.split(",").map((d) => d.trim()).filter((d) => d.length > 0)
   ) ?? [];
-  logger92.debug(
+  logger93.debug(
     `Loaded ${parsed.length} disallowed domains from WORKER_DISALLOWED_DOMAINS`
   );
   return parsed;
 }
-var logger92;
+var logger93;
 var init_network_allowlist = __esm({
   "src/gateway/config/network-allowlist.ts"() {
     "use strict";
     init_src();
-    logger92 = createLogger("network-allowlist");
+    logger93 = createLogger("network-allowlist");
   }
 });
 
@@ -28640,7 +29228,7 @@ var init_policy_composer = __esm({
 });
 
 // src/gateway/proxy/egress-judge/judge.ts
-var logger93;
+var logger94;
 var init_judge = __esm({
   "src/gateway/proxy/egress-judge/judge.ts"() {
     "use strict";
@@ -28649,7 +29237,7 @@ var init_judge = __esm({
     init_cache();
     init_circuit_breaker();
     init_policy_composer();
-    logger93 = createLogger("egress-judge");
+    logger94 = createLogger("egress-judge");
   }
 });
 
@@ -28686,7 +29274,7 @@ async function checkDomainAccess(hostname, agentId, organizationId, requestConte
         organizationId
       );
       if (denied) {
-        logger94.debug(`Domain ${hostname} denied via grant (agent: ${agentId})`);
+        logger95.debug(`Domain ${hostname} denied via grant (agent: ${agentId})`);
         return { allowed: false, source: "grant" };
       }
     }
@@ -28699,7 +29287,7 @@ async function checkDomainAccess(hostname, agentId, organizationId, requestConte
       organizationId
     );
     if (granted) {
-      logger94.debug(`Domain ${hostname} allowed via grant (agent: ${agentId})`);
+      logger95.debug(`Domain ${hostname} allowed via grant (agent: ${agentId})`);
       return { allowed: true, source: "grant" };
     }
   }
@@ -28895,13 +29483,13 @@ function validateProxyAuth(req) {
   }
   const tokenData = verifyWorkerToken(creds.token);
   if (!tokenData) {
-    logger94.warn(
+    logger95.warn(
       `Proxy auth failed: invalid token (claimed deployment: ${creds.deploymentName})`
     );
     return null;
   }
   if (tokenData.jti && getRevokedTokenStore().isRevokedCached(tokenData.jti)) {
-    logger94.warn(
+    logger95.warn(
       `Proxy auth failed: revoked jti (claimed deployment: ${creds.deploymentName})`
     );
     return null;
@@ -28911,7 +29499,7 @@ function validateProxyAuth(req) {
     Buffer.from(creds.deploymentName)
   );
   if (!deploymentMatch) {
-    logger94.warn(
+    logger95.warn(
       `Proxy auth failed: deployment mismatch (claimed: ${creds.deploymentName}, token: ${tokenData.deploymentName})`
     );
     return null;
@@ -28953,7 +29541,7 @@ function logAccessDecision(method, hostname, deploymentName, agentId, decision)
   if (decision.allowed && decision.source === "global") {
     return;
   }
-  logger94.info("egress-decision", {
+  logger95.info("egress-decision", {
     method,
     hostname,
     deploymentName,
@@ -28981,7 +29569,7 @@ async function handleConnect(req, clientSocket, head) {
   const url = req.url || "";
   const hostname = extractConnectHostname(url);
   if (!hostname) {
-    logger94.warn(`Invalid CONNECT request: ${url}`);
+    logger95.warn(`Invalid CONNECT request: ${url}`);
     clientSocket.write("HTTP/1.1 400 Bad Request\r\n\r\n");
     clientSocket.end();
     return;
@@ -28989,9 +29577,9 @@ async function handleConnect(req, clientSocket, head) {
   let targetSocket = null;
   clientSocket.on("error", (err) => {
     if (err.code === "ECONNRESET") {
-      logger94.debug(`Client disconnected for ${hostname} (ECONNRESET)`);
+      logger95.debug(`Client disconnected for ${hostname} (ECONNRESET)`);
     } else {
-      logger94.debug(`Client connection error for ${hostname}: ${err.message}`);
+      logger95.debug(`Client connection error for ${hostname}: ${err.message}`);
     }
     try {
       targetSocket?.end();
@@ -29006,7 +29594,7 @@ async function handleConnect(req, clientSocket, head) {
   });
   const auth = validateProxyAuth(req);
   if (!auth) {
-    logger94.warn(`Proxy auth required for CONNECT to ${hostname}`);
+    logger95.warn(`Proxy auth required for CONNECT to ${hostname}`);
     try {
       clientSocket.write(
         'HTTP/1.1 407 Proxy Authentication Required\r\nProxy-Authenticate: Basic realm="lobu-proxy"\r\n\r\n'
@@ -29031,7 +29619,7 @@ async function handleConnect(req, clientSocket, head) {
   );
   if (!decision.allowed) {
     const reason = decision.judge?.reason ?? `Domain not allowed: ${hostname}`;
-    logger94.warn(
+    logger95.warn(
       `Blocked CONNECT to ${hostname} (deployment: ${deploymentName}) - ${reason}`
     );
     try {
@@ -29049,7 +29637,7 @@ Content-Type: text/plain\r
   }
   const targetResolution = await resolveAndValidateTarget(hostname);
   if (!targetResolution.ok) {
-    logger94.warn(
+    logger95.warn(
       `Blocked CONNECT to ${hostname} (deployment: ${deploymentName}) - ${targetResolution.reason}`
     );
     try {
@@ -29071,17 +29659,17 @@ ${targetResolution.clientMessage}\r
     clientSocket.end();
     return;
   }
-  logger94.debug(`Allowing CONNECT to ${hostname} via ${resolvedIp}`);
+  logger95.debug(`Allowing CONNECT to ${hostname} via ${resolvedIp}`);
   const [host, portStr] = url.split(":");
   const port = portStr ? Number.parseInt(portStr, 10) : 443;
   if (!host) {
-    logger94.warn(`Invalid CONNECT host: ${url}`);
+    logger95.warn(`Invalid CONNECT host: ${url}`);
     clientSocket.write("HTTP/1.1 400 Bad Request\r\n\r\n");
     clientSocket.end();
     return;
   }
   if (!Number.isInteger(port) || port < 1 || port > 65535) {
-    logger94.warn(`Invalid CONNECT port: ${url}`);
+    logger95.warn(`Invalid CONNECT port: ${url}`);
     clientSocket.write("HTTP/1.1 400 Bad Request\r\n\r\n");
     clientSocket.end();
     return;
@@ -29094,7 +29682,7 @@ ${targetResolution.clientMessage}\r
   });
   targetSocket = tunnelSocket;
   tunnelSocket.on("error", (err) => {
-    logger94.debug(`Target connection error for ${hostname}: ${err.message}`);
+    logger95.debug(`Target connection error for ${hostname}: ${err.message}`);
     try {
       clientSocket.end();
     } catch {
@@ -29125,7 +29713,7 @@ async function handleProxyRequest(req, res) {
   const hostname = parsedUrl.hostname;
   const auth = validateProxyAuth(req);
   if (!auth) {
-    logger94.warn(`Proxy auth required for ${req.method} ${hostname}`);
+    logger95.warn(`Proxy auth required for ${req.method} ${hostname}`);
     res.writeHead(407, {
       "Content-Type": "text/plain",
       "Proxy-Authenticate": 'Basic realm="lobu-proxy"'
@@ -29147,7 +29735,7 @@ async function handleProxyRequest(req, res) {
   );
   if (!decision.allowed) {
     const reason = decision.judge?.reason ?? `Domain not allowed: ${hostname}`;
-    logger94.warn(
+    logger95.warn(
       `Blocked request to ${hostname} (deployment: ${deploymentName}) - ${reason}`
     );
     res.writeHead(403, escapeHeaderValue(reason), {
@@ -29161,7 +29749,7 @@ async function handleProxyRequest(req, res) {
   }
   const targetResolution = await resolveAndValidateTarget(hostname);
   if (!targetResolution.ok) {
-    logger94.warn(
+    logger95.warn(
       `Blocked request to ${hostname} (deployment: ${deploymentName}) - ${targetResolution.reason}`
     );
     res.writeHead(targetResolution.statusCode ?? 502, {
@@ -29177,7 +29765,7 @@ async function handleProxyRequest(req, res) {
     res.end("Internal proxy error\n");
     return;
   }
-  logger94.debug(
+  logger95.debug(
     `Proxying ${req.method} ${hostname}${parsedUrl.pathname} via ${resolvedIp}`
   );
   const forwardHeaders = { ...req.headers };
@@ -29194,7 +29782,7 @@ async function handleProxyRequest(req, res) {
     proxyRes.pipe(res);
   });
   proxyReq.on("error", (err) => {
-    logger94.error(`Proxy request error for ${hostname}:`, err.message);
+    logger95.error(`Proxy request error for ${hostname}:`, err.message);
     if (!res.headersSent) {
       res.writeHead(502, { "Content-Type": "text/plain" });
       res.end("Bad Gateway: Could not reach target server\n");
@@ -29209,7 +29797,7 @@ function startHttpProxy(port = 8118, host = "::") {
     const global = getGlobalConfig();
     const server = http.createServer((req, res) => {
       handleProxyRequest(req, res).catch((err) => {
-        logger94.error("Error handling proxy request:", err);
+        logger95.error("Error handling proxy request:", err);
         if (!res.headersSent) {
           res.writeHead(500, { "Content-Type": "text/plain" });
           res.end("Internal proxy error\n");
@@ -29218,7 +29806,7 @@ function startHttpProxy(port = 8118, host = "::") {
     });
     server.on("connect", (req, clientSocket, head) => {
       handleConnect(req, clientSocket, head).catch((err) => {
-        logger94.error("Error handling CONNECT:", err);
+        logger95.error("Error handling CONNECT:", err);
         try {
           clientSocket.write("HTTP/1.1 500 Internal Server Error\r\n\r\n");
           clientSocket.end();
@@ -29227,13 +29815,13 @@ function startHttpProxy(port = 8118, host = "::") {
       });
     });
     server.on("error", (err) => {
-      logger94.error("HTTP proxy server error:", err);
+      logger95.error("HTTP proxy server error:", err);
       reject(err);
     });
     server.listen(port, host, () => {
       server.removeAllListeners("error");
       server.on("error", (err) => {
-        logger94.error("HTTP proxy server error:", err);
+        logger95.error("HTTP proxy server error:", err);
       });
       let mode;
       if (isUnrestrictedMode(global.allowedDomains)) {
@@ -29243,7 +29831,7 @@ function startHttpProxy(port = 8118, host = "::") {
       } else {
         mode = "complete-isolation";
       }
-      logger94.debug(
+      logger95.debug(
         `HTTP proxy started on ${host}:${port} (mode=${mode}, allowed=${global.allowedDomains.length}, denied=${global.deniedDomains.length})`
       );
       resolve6(server);
@@ -29254,16 +29842,16 @@ function stopHttpProxy(server) {
   return new Promise((resolve6, reject) => {
     server.close((err) => {
       if (err) {
-        logger94.error("Error stopping HTTP proxy:", err);
+        logger95.error("Error stopping HTTP proxy:", err);
         reject(err);
       } else {
-        logger94.info("HTTP proxy stopped");
+        logger95.info("HTTP proxy stopped");
         resolve6();
       }
     });
   });
 }
-var logger94, blockedIpv4Ranges, blockedIpv6Ranges, blockedIpv4List, blockedIpv6List, globalConfig, proxyGrantStore, proxyPolicyStore, proxyEgressJudge, dnsLookupOverride;
+var logger95, blockedIpv4Ranges, blockedIpv6Ranges, blockedIpv4List, blockedIpv6List, globalConfig, proxyGrantStore, proxyPolicyStore, proxyEgressJudge, dnsLookupOverride;
 var init_http_proxy = __esm({
   "src/gateway/proxy/http-proxy.ts"() {
     "use strict";
@@ -29271,7 +29859,7 @@ var init_http_proxy = __esm({
     init_network_allowlist();
     init_revoked_token_store();
     init_judge();
-    logger94 = createLogger("http-proxy");
+    logger95 = createLogger("http-proxy");
     blockedIpv4Ranges = [
       ["0.0.0.0", 8],
       ["10.0.0.0", 8],
@@ -29320,26 +29908,26 @@ async function startFilteringProxy() {
   const host = "127.0.0.1";
   try {
     proxyServer = await startHttpProxy(port, host);
-    logger95.debug(`HTTP proxy started on ${host}:${port}`);
+    logger96.debug(`HTTP proxy started on ${host}:${port}`);
   } catch (error) {
-    logger95.error("Failed to start HTTP proxy:", error);
+    logger96.error("Failed to start HTTP proxy:", error);
     throw error;
   }
 }
 async function stopFilteringProxy() {
   if (proxyServer) {
-    logger95.info("Stopping HTTP proxy...");
+    logger96.info("Stopping HTTP proxy...");
     await stopHttpProxy(proxyServer);
     proxyServer = null;
   }
 }
-var logger95, proxyServer;
+var logger96, proxyServer;
 var init_proxy_manager = __esm({
   "src/gateway/proxy/proxy-manager.ts"() {
     "use strict";
     init_src();
     init_http_proxy();
-    logger95 = createLogger("proxy-manager");
+    logger96 = createLogger("proxy-manager");
     proxyServer = null;
     process.on("SIGTERM", async () => {
       await stopFilteringProxy();
@@ -43037,7 +43625,7 @@ async function createAuthRun(params) {
 async function createConnectorOperationRun(params) {
   const sql = getDb();
   const approvalStatus = params.approvalMode === "queued" ? "pending" : "auto";
-  const status = params.approvalMode === "queued" ? "pending" : "running";
+  const status = params.approvalMode === "inline" ? "running" : "pending";
   const defRows = await sql`
     SELECT version FROM connector_definitions
     WHERE key = ${params.connectorKey}
@@ -47806,7 +48394,7 @@ import path11 from "node:path";
 import { fileURLToPath as fileURLToPath8 } from "node:url";
 import v8 from "node:v8";
 import { getRequestListener } from "@hono/node-server";
-import { Hono as Hono27 } from "hono";
+import { Hono as Hono29 } from "hono";
 
 // src/dev-vite.ts
 import { existsSync as existsSync7 } from "node:fs";
@@ -47817,7 +48405,7 @@ import { fileURLToPath as fileURLToPath7 } from "node:url";
 import fs5 from "node:fs/promises";
 import path9 from "node:path";
 import { fileURLToPath as fileURLToPath6 } from "node:url";
-import { Hono as Hono26 } from "hono";
+import { Hono as Hono28 } from "hono";
 import { compress } from "hono/compress";
 import { cors as cors2 } from "hono/cors";
 import { pinoLogger } from "hono-pino";
@@ -47909,7 +48497,7 @@ async function mcpAuth(c, next) {
 
 // src/auth/oauth/routes.ts
 init_client();
-import { Hono as Hono21 } from "hono";
+import { Hono as Hono22 } from "hono";
 
 // src/utils/rate-limiter.ts
 var RateLimiter = class {
@@ -48052,7 +48640,7 @@ init_provider();
 init_scopes();
 init_utils();
 init_public_origin();
-var oauthRoutes = new Hono21();
+var oauthRoutes = new Hono22();
 async function parseRequestBody(c) {
   const contentType = c.req.header("content-type") || "";
   if (contentType.includes("application/x-www-form-urlencoded")) {
@@ -48654,10 +49242,10 @@ init_errors2();
 init_base_url();
 init_auth2();
 import { createHmac } from "node:crypto";
-import { Hono as Hono22 } from "hono";
+import { Hono as Hono23 } from "hono";
 init_clients();
 init_tokens();
-var credentialRoutes = new Hono22();
+var credentialRoutes = new Hono23();
 function getAuthenticatedUser(c) {
   const user = c.get("user");
   if (!user) {
@@ -48973,7 +49561,7 @@ init_run_statuses();
 init_url_builder();
 init_oauth_providers();
 import { createHash as createHash12, randomBytes as randomBytes12 } from "node:crypto";
-import { Hono as Hono23 } from "hono";
+import { Hono as Hono24 } from "hono";
 import { createMiddleware } from "hono/factory";
 function buildPkceVerifier() {
   return randomBytes12(32).toString("base64url");
@@ -48993,7 +49581,7 @@ var requireConnectToken = createMiddleware(async (c, next) => {
 function getBaseUrl2(c) {
   return getPublicWebUrl(c.req.url) ?? "";
 }
-var connectRoutes = new Hono23();
+var connectRoutes = new Hono24();
 async function getLatestValidationRun(connectionId, createdAfter) {
   const sql = getDb();
   const rows = await sql`
@@ -49804,7 +50392,7 @@ async function restGetFeedForRun(c) {
 init_src();
 import { readFile as readFile9 } from "node:fs/promises";
 import { resolve as resolve5 } from "node:path";
-import { Hono as Hono25 } from "hono";
+import { Hono as Hono26 } from "hono";
 init_client();
 init_provider_secrets();
 init_client2();
@@ -49814,11 +50402,12 @@ init_auth_profiles_manager();
 init_public_origin();
 
 // src/lobu/client-routes.ts
-import { Hono as Hono24 } from "hono";
+import { Hono as Hono25 } from "hono";
 init_clients();
 init_client();
 
 // src/mcp-handler.ts
+init_sse_abort_bridge();
 init_clients();
 init_tool_access();
 init_client();
@@ -57563,6 +58152,86 @@ async function handleListAvailable(args, ctx) {
     offset: result.offset
   };
 }
+async function waitForDeviceActionRun(runId, organizationId) {
+  const sql = getDb();
+  const QUEUE_BUDGET_MS = 6e4;
+  const POST_CLAIM_BUDGET_MS = 95e3;
+  const POLL_MS = 500;
+  const queueDeadline = Date.now() + QUEUE_BUDGET_MS;
+  let claimedAtMs = null;
+  while (true) {
+    const rows = await sql`
+      SELECT status, action_output, error_message, claimed_at
+      FROM runs
+      WHERE id = ${runId} AND organization_id = ${organizationId}
+      LIMIT 1
+    `;
+    const row = rows[0];
+    if (!row) {
+      return {
+        status: "failed",
+        error_message: `Run ${runId} disappeared from runs table while waiting.`
+      };
+    }
+    if (row.status === "completed") {
+      return {
+        status: "completed",
+        output: row.action_output ?? {}
+      };
+    }
+    if (row.status === "failed" || row.status === "timeout") {
+      return {
+        status: row.status,
+        error_message: row.error_message ?? `Run ${runId} ${row.status}`
+      };
+    }
+    if (row.claimed_at && claimedAtMs == null) {
+      claimedAtMs = row.claimed_at instanceof Date ? row.claimed_at.getTime() : new Date(row.claimed_at).getTime();
+    }
+    const now = Date.now();
+    if (claimedAtMs != null) {
+      if (now - claimedAtMs >= POST_CLAIM_BUDGET_MS) break;
+    } else {
+      if (now >= queueDeadline) break;
+    }
+    await new Promise((r) => setTimeout(r, POLL_MS));
+  }
+  const updated = await sql`
+    UPDATE runs
+    SET status = 'timeout',
+        completed_at = current_timestamp,
+        error_message = ${"waitForDeviceActionRun: device worker did not complete in time"}
+    WHERE id = ${runId}
+      AND organization_id = ${organizationId}
+      AND status IN ('pending', 'running')
+    RETURNING id
+  `;
+  if (updated.length === 0) {
+    const finalRows = await sql`
+      SELECT status, action_output, error_message
+      FROM runs
+      WHERE id = ${runId} AND organization_id = ${organizationId}
+      LIMIT 1
+    `;
+    const final = finalRows[0];
+    if (final?.status === "completed") {
+      return {
+        status: "completed",
+        output: final.action_output ?? {}
+      };
+    }
+    if (final?.status === "failed") {
+      return {
+        status: "failed",
+        error_message: final.error_message ?? `Run ${runId} failed`
+      };
+    }
+  }
+  return {
+    status: "timeout",
+    error_message: claimedAtMs != null ? `Run ${runId} claimed but the device worker didn't finish within ${POST_CLAIM_BUDGET_MS}ms.` : `Run ${runId} was never claimed within ${QUEUE_BUDGET_MS}ms \u2014 the chrome-extension / device worker may be offline.`
+  };
+}
 async function handleExecute(args, env2, ctx) {
   const sql = getDb();
   const resolved = await getOperationForConnection(
@@ -57585,13 +58254,23 @@ async function handleExecute(args, env2, ctx) {
     };
   }
   const shouldQueue = mode === "approval";
+  const defRows = await sql`
+    SELECT runtime FROM connector_definitions
+    WHERE key = ${connection.connector_key}
+      AND organization_id = ${ctx.organizationId}
+      AND status = 'active'
+    ORDER BY updated_at DESC, id DESC
+    LIMIT 1
+  `;
+  const isDeviceBound = defRows[0]?.runtime != null;
+  const approvalMode = shouldQueue ? "queued" : isDeviceBound ? "device" : "inline";
   const runId = await createConnectorOperationRun({
     organizationId: ctx.organizationId,
     connectionId: connection.id,
     connectorKey: connection.connector_key,
     operationKey: operation.operation_key,
     operationInput: input,
-    approvalMode: shouldQueue ? "queued" : "inline",
+    approvalMode,
     requireCompiledCode: operation.backend === "local_action"
   });
   if (args.watcher_source) {
@@ -57666,6 +58345,31 @@ async function handleExecute(args, env2, ctx) {
       message: `Operation '${operation.name}' requires approval. Share the approval_url with the user to confirm.`
     };
   }
+  if (approvalMode === "device") {
+    const result2 = await waitForDeviceActionRun(runId, ctx.organizationId);
+    if (result2.status === "completed") {
+      return {
+        action: "execute",
+        run_id: runId,
+        status: "completed",
+        output: result2.output ?? {}
+      };
+    }
+    if (result2.status === "timeout") {
+      return {
+        action: "execute",
+        run_id: runId,
+        status: "timeout",
+        error_message: result2.error_message ?? "Device action run timed out."
+      };
+    }
+    return {
+      action: "execute",
+      run_id: runId,
+      status: "failed",
+      error_message: result2.error_message ?? "Device action run failed."
+    };
+  }
   const result = await executeOperationInline(
     runId,
     ctx.organizationId,
@@ -67205,7 +67909,7 @@ async function sseToJson(response) {
   return response;
 }
 var SSE_HEARTBEAT_INTERVAL_MS = 15e3;
-function withSSEHeartbeat(response) {
+function withSSEHeartbeat(response, signal) {
   if (!response.headers.get("content-type")?.includes("text/event-stream") || !response.body) {
     return response;
   }
@@ -67226,22 +67930,37 @@ function withSSEHeartbeat(response) {
     if (intervalId) clearInterval(intervalId);
     writer.abort(reason).catch(() => void 0);
   };
+  const adapter = {
+    get aborted() {
+      return terminated;
+    },
+    get closed() {
+      return terminated;
+    },
+    abort() {
+      abortWriter(new Error("Request aborted"));
+    }
+  };
   intervalId = setInterval(() => {
     writer.write(heartbeat2).catch(() => abortWriter(new Error("SSE heartbeat write failed")));
   }, SSE_HEARTBEAT_INTERVAL_MS);
+  const detachAbortBridge = bindRequestAbortToStream(signal, adapter);
   response.body.pipeTo(
     new WritableStream({
       write(chunk) {
         return writer.write(chunk);
       },
       close() {
+        detachAbortBridge();
         closeWriter();
       },
       abort(reason) {
+        detachAbortBridge();
         abortWriter(reason);
       }
     })
   ).catch(() => {
+    detachAbortBridge();
     abortWriter(new Error("Source SSE stream error"));
   });
   return new Response(readable, { status: response.status, headers: response.headers });
@@ -67251,7 +67970,7 @@ async function handleAndMaybeConvert(transport, req, wantsSSE) {
   if (!wantsSSE && response.headers.get("content-type")?.includes("text/event-stream")) {
     return sseToJson(response);
   }
-  return withSSEHeartbeat(response);
+  return withSSEHeartbeat(response, req.signal);
 }
 async function resolveAuthWithInstructions(c, req) {
   const authCtx = extractAuthContext(c);
@@ -67484,8 +68203,8 @@ async function handleMcp(c) {
 
 // src/lobu/client-routes.ts
 init_org_context();
-var routes = new Hono24();
-var platformSchemaRoutes = new Hono24();
+var routes = new Hono25();
+var platformSchemaRoutes = new Hono25();
 var LOBU_FIRST_PARTY_SOFTWARE_IDS = /* @__PURE__ */ new Set([
   "lobu-cli",
   "lobu",
@@ -67874,7 +68593,7 @@ platformSchemaRoutes.get("/:platform", (c) => {
 init_gateway3();
 init_postgres_stores();
 init_org_context();
-var routes2 = new Hono25();
+var routes2 = new Hono26();
 function toStringArray(value) {
   if (Array.isArray(value)) return value.map(String);
   if (typeof value === "string") {
@@ -70620,6 +71339,7 @@ function generateOpenAPISpec(serverUrl) {
 
 // src/index.ts
 init_public_origin();
+init_embedded_deployment();
 
 // src/scheduled/scheduler-health.ts
 init_client();
@@ -70796,6 +71516,186 @@ async function joinPublicOrganization({
 // src/index.ts
 init_multi_tenant();
 
+// src/gateway/routes/internal/smoke.ts
+init_src();
+init_client();
+import { timingSafeEqual as timingSafeEqual3 } from "node:crypto";
+import { Hono as Hono27 } from "hono";
+var logger97 = createLogger("smoke-dispatch");
+function compareTokens(provided, expected) {
+  if (provided.length !== expected.length) return false;
+  try {
+    return timingSafeEqual3(Buffer.from(provided), Buffer.from(expected));
+  } catch {
+    return false;
+  }
+}
+var FORWARDED_HEADERS = [
+  "x-forwarded-for",
+  "x-forwarded-host",
+  "x-forwarded-proto",
+  "x-forwarded-port",
+  "x-forwarded-server",
+  "x-real-ip",
+  "forwarded"
+];
+function createSmokeRoutes() {
+  const app3 = new Hono27();
+  app3.post("/dispatch", async (c) => {
+    const expected = process.env.SMOKE_TEST_TOKEN ?? "";
+    const smokeAgentId = (process.env.SMOKE_TEST_AGENT_ID ?? "").trim();
+    const smokeOrgId = (process.env.SMOKE_TEST_ORG_ID ?? "").trim();
+    if (expected.length === 0 || smokeAgentId === "" || smokeOrgId === "") {
+      return c.json(
+        {
+          error: "Smoke dispatch disabled (SMOKE_TEST_TOKEN/SMOKE_TEST_AGENT_ID/SMOKE_TEST_ORG_ID unset)"
+        },
+        503
+      );
+    }
+    for (const h of FORWARDED_HEADERS) {
+      if (c.req.header(h)) {
+        logger97.warn(
+          `Smoke dispatch refused: ${h} header present (request came through ingress)`
+        );
+        return c.json({ error: "Forwarded request refused" }, 403);
+      }
+    }
+    const allowedHost = (process.env.SMOKE_TEST_ALLOWED_HOST ?? "").trim();
+    if (allowedHost !== "") {
+      const rawHost = (c.req.header("host") ?? "").toLowerCase();
+      const hostPart = rawHost.split(":")[0] ?? "";
+      const expected2 = allowedHost.toLowerCase();
+      if (hostPart !== expected2 && !hostPart.startsWith(`${expected2}.`)) {
+        logger97.warn(
+          `Smoke dispatch refused: Host '${rawHost}' does not match SMOKE_TEST_ALLOWED_HOST '${allowedHost}'`
+        );
+        return c.json({ error: "Host header refused" }, 403);
+      }
+    }
+    const auth = c.req.header("authorization") ?? "";
+    if (!auth.startsWith("Bearer ")) {
+      return c.json({ error: "Missing bearer token" }, 401);
+    }
+    const provided = auth.substring(7);
+    if (!compareTokens(provided, expected)) {
+      return c.json({ error: "Invalid smoke token" }, 401);
+    }
+    let body2;
+    try {
+      body2 = await c.req.json();
+    } catch {
+      return c.json({ error: "Invalid JSON body" }, 400);
+    }
+    const agentId = smokeAgentId;
+    const organizationId = smokeOrgId;
+    const conversationId = body2.conversationId?.trim();
+    const messageText = body2.messageText?.trim() || "smoke-test ping";
+    if (!conversationId) {
+      return c.json({ error: "conversationId is required" }, 400);
+    }
+    if (!conversationId.startsWith("smoke-")) {
+      return c.json(
+        {
+          error: "conversationId must start with 'smoke-' for safety"
+        },
+        400
+      );
+    }
+    const idempotencyKey = `smoke:${conversationId}`;
+    const messageId = `smoke-msg-${Date.now()}`;
+    const payload = {
+      platform: "smoke",
+      userId: "smoke-user",
+      botId: "smoke",
+      conversationId,
+      teamId: "smoke",
+      agentId,
+      organizationId,
+      messageId,
+      messageText,
+      channelId: conversationId,
+      platformMetadata: {
+        agentId,
+        chatId: conversationId,
+        senderId: "smoke-user",
+        responseChannel: conversationId,
+        responseId: messageId,
+        responseThreadId: conversationId
+      },
+      agentOptions: {}
+    };
+    const sql = getDb();
+    try {
+      const result = await sql`
+        INSERT INTO public.runs (
+          run_type,
+          queue_name,
+          action_input,
+          idempotency_key,
+          max_attempts,
+          attempts,
+          status,
+          run_at,
+          priority,
+          retry_delay_seconds
+        ) VALUES (
+          'chat_message',
+          'messages',
+          ${sql.json(payload)},
+          ${idempotencyKey},
+          1,
+          0,
+          'pending',
+          now(),
+          0,
+          NULL
+        )
+        ON CONFLICT (idempotency_key)
+          WHERE idempotency_key IS NOT NULL
+            AND status IN ('pending', 'claimed', 'running')
+        DO NOTHING
+        RETURNING id
+      `;
+      let runId = null;
+      if (result.length > 0 && result[0]) {
+        runId = Number(result[0].id);
+      } else {
+        const existing = await sql`
+          SELECT id FROM public.runs
+          WHERE idempotency_key = ${idempotencyKey}
+            AND status IN ('pending', 'claimed', 'running')
+          ORDER BY id DESC
+          LIMIT 1
+        `;
+        if (existing.length > 0 && existing[0]) {
+          runId = Number(existing[0].id);
+        }
+      }
+      if (runId === null) {
+        return c.json({ error: "Failed to enqueue smoke run" }, 500);
+      }
+      try {
+        await sql`SELECT pg_notify('runs_lobu:messages', 'chat_message')`;
+      } catch (err) {
+        logger97.warn(
+          `pg_notify after smoke dispatch failed (non-fatal): ${err instanceof Error ? err.message : String(err)}`
+        );
+      }
+      logger97.info(
+        `Smoke dispatch: runId=${runId} agentId=${agentId} org=${organizationId} conv=${conversationId}`
+      );
+      return c.json({ runId, idempotencyKey });
+    } catch (err) {
+      logger97.error(
+        `Smoke dispatch INSERT failed: ${err instanceof Error ? err.message : String(err)}`
+      );
+      return c.json({ error: "Internal error" }, 500);
+    }
+  });
+  return app3;
+}
+
 // src/worker-api.ts
 init_src();
 init_auth2();
@@ -70866,7 +71766,7 @@ import { createHash as createHash14, randomUUID as randomUUID16 } from "node:cry
 // src/gateway/services/agent-threads.ts
 init_src();
 import { randomUUID as randomUUID15 } from "node:crypto";
-var logger96 = createLogger("agent-threads");
+var logger98 = createLogger("agent-threads");
 var TOKEN_EXPIRATION_MS2 = 24 * 60 * 60 * 1e3;
 async function createThreadForAgent(deps, args) {
   const { sessionManager } = deps;
@@ -70898,7 +71798,7 @@ async function createThreadForAgent(deps, args) {
     isEphemeral: false
   };
   await sessionManager.setSession(session);
-  logger96.info(
+  logger98.info(
     `Created thread ${conversationId} for agent ${agentId}${reason ? ` (reason=${reason})` : ""}`
   );
   return { threadId: conversationId, token, expiresAt };
@@ -73362,6 +74262,8 @@ async function postAuthSignal(c) {
 async function completeActionRun(c) {
   try {
     const req = await c.req.json();
+    const denied = await authorizeRunForWorker(c, req.run_id, req.worker_id);
+    if (denied) return denied;
     const sql = getDb();
     const updatedRuns = await sql`
       UPDATE runs
@@ -73370,8 +74272,17 @@ async function completeActionRun(c) {
           action_output = ${req.action_output ? sql.json(req.action_output) : null},
           error_message = ${req.error_message ?? null}
       WHERE id = ${req.run_id}
+        AND status = 'running'
+        AND claimed_by = ${req.worker_id}
       RETURNING organization_id, action_key
     `;
+    if (updatedRuns.length === 0) {
+      logger_default.info(
+        { run_id: req.run_id, worker_id: req.worker_id, claimed_status: req.status },
+        "[completeActionRun] no-op: run already in terminal state (likely gateway timeout)"
+      );
+      return c.json({ success: false, reason: "already_finalized" });
+    }
     const organizationId = updatedRuns[0]?.organization_id;
     const actionKey = updatedRuns[0]?.action_key ?? "Action";
     if (organizationId) {
@@ -74218,7 +75129,7 @@ async function serveStaticFile(c, filePath) {
   new Uint8Array(ab).set(body2);
   return c.body(new Uint8Array(ab));
 }
-var app = new Hono26();
+var app = new Hono28();
 app.use("/*", compress({ threshold: 1024 }));
 app.use(
   "/*",
@@ -74250,8 +75161,13 @@ app.use("/*", async (c, next) => {
   if (contentType.startsWith("text/html")) {
     const rawFrameAncestors = c.env.FRAME_ANCESTORS?.trim();
     const frameAncestors = rawFrameAncestors ? rawFrameAncestors.split(/[\s,]+/).map((entry) => entry.trim()).filter((entry) => isValidFrameAncestor(entry)).join(" ") : "https://lobu.ai https://*.lobu.ai";
-    const path12 = new URL(c.req.url).pathname;
-    const extensionAllowed = path12 === "/embedded" ? " chrome-extension:" : "";
+    const extraExtensionIds = (c.env.LOBU_OWLETTO_EXTENSION_IDS ?? "").split(",").map((s) => s.trim()).filter((s) => /^[a-p]{32}$/.test(s));
+    const ownedExtensionIds = [
+      // canonical, derived from apps/chrome/manifest.json's `key`
+      "amnnhclgmbldmfcfamonoggjhfidemmm",
+      ...extraExtensionIds
+    ];
+    const extensionAllowed = ownedExtensionIds.map((id) => ` chrome-extension://${id}`).join("");
     c.header(
       "Content-Security-Policy",
       `frame-ancestors 'self' ${frameAncestors}${extensionAllowed}`
@@ -74323,6 +75239,17 @@ app.get("/health/ready", async (c) => {
     );
   }
 });
+app.get("/health/orchestrator", (c) => {
+  const count = getReservedLockCount();
+  const cap = getMaxReservedLocks();
+  const nearCap = cap > 0 && count >= Math.ceil(cap * 0.8);
+  return c.json({
+    status: "ok",
+    reserved_conversation_locks: count,
+    reserved_conversation_locks_cap: cap,
+    near_cap: nearCap
+  });
+});
 app.get("/health/scheduler", async (c) => {
   try {
     const health = await getSchedulerHealth(c.env);
@@ -74401,6 +75328,7 @@ app.get("/legal", (c) => {
 </html>`);
 });
 app.get("/api/health", restHealth);
+app.route("/api/internal/smoke", createSmokeRoutes());
 app.use("/api/workers/*", async (c, next) => {
   const expected = c.env.WORKER_API_TOKEN;
   const provided = c.req.header("Authorization")?.replace("Bearer ", "");
@@ -74416,7 +75344,13 @@ app.use("/api/workers/*", async (c, next) => {
         "/api/workers/poll",
         "/api/workers/heartbeat",
         "/api/workers/stream",
-        "/api/workers/complete"
+        "/api/workers/complete",
+        // Action runs (run_type='action') finalize via /complete-action,
+        // which persists action_output. The handler still goes through
+        // authorizeRunForWorker so a user worker can only finalize runs
+        // it claimed. Required for chrome-extension action tools to
+        // return their observation back to the gateway.
+        "/api/workers/complete-action"
       ]);
       const requestPath = new URL(c.req.url).pathname;
       const isAuthProfileSubpath = requestPath.startsWith("/api/workers/me/auth-profiles");
@@ -74970,7 +75904,6 @@ init_gateway3();
 init_client();
 init_connect_tokens();
 init_logger();
-init_pg_errors();
 var REAPER_ADVISORY_LOCK_KEY = 1919841138;
 var DEFAULT_STALE_AFTER_SECONDS = 120;
 function staleAfterSeconds() {
@@ -74992,56 +75925,75 @@ async function reapStaleRuns() {
     try {
       const errorMessage3 = "worker_heartbeat_lost";
       const reaped = await reserved`
-        UPDATE public.runs
-        SET status = 'timeout',
-            completed_at = current_timestamp,
-            error_message = ${errorMessage3}
-        WHERE run_type IN ('sync', 'action', 'embed_backfill', 'auth')
-          AND status IN ('claimed', 'running')
-          AND (
-            (last_heartbeat_at IS NULL
-             AND COALESCE(claimed_at, created_at)
-                 < current_timestamp - (${thresholdSeconds}::int * interval '1 second'))
-            OR
-            (last_heartbeat_at IS NOT NULL
-             AND last_heartbeat_at
-                 < current_timestamp - (${thresholdSeconds}::int * interval '1 second'))
+        WITH timed_out AS (
+          UPDATE public.runs
+          SET status = 'timeout',
+              completed_at = current_timestamp,
+              error_message = ${errorMessage3}
+          WHERE run_type IN ('sync', 'action', 'embed_backfill', 'auth')
+            AND status IN ('claimed', 'running')
+            AND (
+              (last_heartbeat_at IS NULL
+               AND COALESCE(claimed_at, created_at)
+                   < current_timestamp - (${thresholdSeconds}::int * interval '1 second'))
+              OR
+              (last_heartbeat_at IS NOT NULL
+               AND last_heartbeat_at
+                   < current_timestamp - (${thresholdSeconds}::int * interval '1 second'))
+            )
+          RETURNING id, run_type, feed_id, connection_id, connector_key, connector_version, organization_id
+        ),
+        retries AS (
+          INSERT INTO public.runs (
+            organization_id, run_type, feed_id, connection_id,
+            connector_key, connector_version, status, approval_status, created_at
           )
-        RETURNING id, run_type, feed_id, connection_id, connector_key, connector_version, organization_id
+          SELECT
+            t.organization_id, 'sync', t.feed_id, t.connection_id,
+            t.connector_key, t.connector_version, 'pending', 'auto', current_timestamp
+          FROM timed_out t
+          WHERE t.run_type = 'sync'
+            AND t.feed_id IS NOT NULL
+            AND NOT EXISTS (
+              -- Look for an unrelated active sync run on the same feed.
+              -- Exclude timed_out.id because in PostgreSQL the sibling
+              -- CTE UPDATE is not visible here (all CTEs see the same
+              -- snapshot), so the row we just reaped still appears as
+              -- running. Without this exclusion, every reap would
+              -- dedupe against itself and no retries would ever land.
+              SELECT 1 FROM public.runs r
+              WHERE r.feed_id = t.feed_id
+                AND r.run_type = 'sync'
+                AND r.status IN ('pending', 'claimed', 'running')
+                AND r.id NOT IN (SELECT id FROM timed_out)
+            )
+          RETURNING id, feed_id
+        )
+        SELECT
+          (SELECT count(*)::int FROM timed_out) AS reaped,
+          (SELECT count(*)::int FROM retries) AS retries_created,
+          (SELECT count(*)::int FROM timed_out
+            WHERE run_type = 'sync' AND feed_id IS NOT NULL) AS sync_eligible
       `;
-      if (reaped.length === 0) {
+      const reapedRow = reaped[0];
+      const reapedCount = reapedRow?.reaped ?? 0;
+      const retriesCreated = reapedRow?.retries_created ?? 0;
+      const syncEligible = reapedRow?.sync_eligible ?? 0;
+      if (reapedCount === 0) {
         return { acquired: true, reaped: 0, retriesCreated: 0 };
       }
       logger_default.warn(
-        { reaped: reaped.length, thresholdSeconds },
+        { reaped: reapedCount, retriesCreated, thresholdSeconds },
         "[reaper] Marked stale connector runs as timeout (worker_heartbeat_lost)"
       );
-      let retriesCreated = 0;
-      for (const row of reaped) {
-        if (row.run_type !== "sync" || !row.feed_id) continue;
-        try {
-          await reserved`
-            INSERT INTO runs (
-              organization_id, run_type, feed_id, connection_id,
-              connector_key, connector_version, status, approval_status, created_at
-            ) VALUES (
-              ${row.organization_id}, 'sync', ${row.feed_id}, ${row.connection_id},
-              ${row.connector_key}, ${row.connector_version}, 'pending', 'auto', current_timestamp
-            )
-          `;
-          retriesCreated += 1;
-        } catch (err) {
-          if (isUniqueViolation(err, "idx_runs_active_sync_per_feed")) {
-            logger_default.info(
-              { feedId: row.feed_id },
-              "[reaper] Skipped sync retry \u2014 another active sync run exists"
-            );
-          } else {
-            logger_default.error({ err, runId: row.id }, "[reaper] Failed to insert sync retry");
-          }
-        }
+      const skippedRetries = syncEligible - retriesCreated;
+      if (skippedRetries > 0) {
+        logger_default.info(
+          { count: skippedRetries },
+          "[reaper] Skipped sync retries \u2014 another active sync run exists (ON CONFLICT DO NOTHING)"
+        );
       }
-      return { acquired: true, reaped: reaped.length, retriesCreated };
+      return { acquired: true, reaped: reapedCount, retriesCreated };
     } finally {
       await reserved`SELECT pg_advisory_unlock(${REAPER_ADVISORY_LOCK_KEY})`;
     }
@@ -75610,7 +76562,7 @@ async function runClassificationReconciliation(_env) {
 init_src();
 init_cron();
 import * as Sentry8 from "@sentry/node";
-var logger97 = createLogger("task-scheduler");
+var logger99 = createLogger("task-scheduler");
 var TASK_QUEUE_NAME = "task";
 function cronSeedKey(name, tick) {
   return `cron:${name}:${tick.toISOString()}`;
@@ -75663,7 +76615,7 @@ var TaskScheduler = class {
       try {
         await this.seedNextCronTick(reg);
       } catch (err) {
-        logger97.error(
+        logger99.error(
           { err, taskName: reg.name, cron: reg.cron },
           "[task-scheduler] Failed to seed cron row at boot; will retry in background"
         );
@@ -75672,7 +76624,7 @@ var TaskScheduler = class {
     }
     await this.queue.work(TASK_QUEUE_NAME, (job) => this.dispatch(job));
     const periodic = [...this.handlers.values()].filter((r) => r.cron).length;
-    logger97.info(
+    logger99.info(
       { total: this.handlers.size, periodic },
       "[task-scheduler] Started"
     );
@@ -75684,12 +76636,12 @@ var TaskScheduler = class {
       setTimeout(() => {
         if (!this.started) return;
         this.seedNextCronTick(reg).then(
-          () => logger97.info(
+          () => logger99.info(
             { taskName: reg.name, cron: reg.cron, attempt: i + 1 },
             "[task-scheduler] Recovered cron seed in background"
           )
         ).catch((err) => {
-          logger97.error(
+          logger99.error(
             { err, taskName: reg.name, cron: reg.cron, attempt: i + 1 },
             "[task-scheduler] Background cron seed retry failed"
           );
@@ -75712,7 +76664,7 @@ var TaskScheduler = class {
     const data = job.data ?? { name: "", payload: {} };
     const reg = this.handlers.get(data.name);
     if (!reg) {
-      logger97.error(
+      logger99.error(
         { taskName: data.name, runId: job.id },
         "[task-scheduler] No handler registered for task; failing run"
       );
@@ -76123,7 +77075,7 @@ async function assertSchemaUpToDate(sql, options) {
 // src/server.ts
 init_workspace();
 dotenv2.config();
-var app2 = new Hono27();
+var app2 = new Hono29();
 var PACKAGE_REPO_ROOT2 = path11.resolve(
   fileURLToPath8(new URL(".", import.meta.url)),
   "../../.."