@band-ai/sdk 0.1.6 → 0.2.0

package/dist/linear.cjs

@@ -31,6 +31,12 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var linear_exports = {};
 __export(linear_exports, {
   DEFAULT_STATUS_MAPPING: () => DEFAULT_STATUS_MAPPING,
+  ELICITATION_BODY_MAX_LENGTH: () => ELICITATION_BODY_MAX_LENGTH,
+  PROVIDER_MAX_LENGTH: () => PROVIDER_MAX_LENGTH,
+  SELECT_OPTION_MAX_LENGTH: () => SELECT_OPTION_MAX_LENGTH,
+  STALE_SESSION_CHECK_INTERVAL_MS: () => STALE_SESSION_CHECK_INTERVAL_MS,
+  STALE_SESSION_THRESHOLD_MS: () => STALE_SESSION_THRESHOLD_MS,
+  StaleSessionGuard: () => StaleSessionGuard,
   buildLinearAuthorizationHeader: () => buildLinearAuthorizationHeader,
   completeLinearSession: () => completeLinearSession,
   createInProcessLinearBridgeDispatcher: () => createInProcessLinearBridgeDispatcher,
@@ -42,12 +48,17 @@ __export(linear_exports, {
   createSqliteSessionRoomStore: () => createSqliteSessionRoomStore,
   dedupeHandles: () => dedupeHandles,
   handleAgentSessionEvent: () => handleAgentSessionEvent,
+  handleAppUserNotification: () => handleAppUserNotification,
   isLinearApiKey: () => isLinearApiKey,
+  isSessionStale: () => isSessionStale,
   postAction: () => postAction,
+  postAuthElicitation: () => postAuthElicitation,
   postElicitation: () => postElicitation,
   postError: () => postError,
   postResponse: () => postResponse,
+  postSelectElicitation: () => postSelectElicitation,
   postThought: () => postThought,
+  sendRecoveryActivityIfStale: () => sendRecoveryActivityIfStale,
   stripHandlePrefix: () => stripHandlePrefix,
   updatePlan: () => updatePlan
 });
@@ -57,13 +68,13 @@ module.exports = __toCommonJS(linear_exports);
 var import_sdk2 = require("@linear/sdk");
 
 // src/core/errors.ts
-var ThenvoiSdkError = class extends Error {
+var BandSdkError = class extends Error {
   constructor(message, cause) {
     super(message, cause !== void 0 ? { cause } : void 0);
-    this.name = "ThenvoiSdkError";
+    this.name = "BandSdkError";
   }
 };
-var UnsupportedFeatureError = class extends ThenvoiSdkError {
+var UnsupportedFeatureError = class extends BandSdkError {
   constructor(message) {
     super(message);
     this.name = "UnsupportedFeatureError";
@@ -99,20 +110,24 @@ function dedupeHandles(handles) {
 
 // src/integrations/linear/activities.ts
 var import_sdk = require("@linear/sdk");
-async function postActivity(client, sessionId, content) {
+var ELICITATION_BODY_MAX_LENGTH = 1e4;
+var SELECT_OPTION_MAX_LENGTH = 200;
+var PROVIDER_MAX_LENGTH = 100;
+async function postActivity(client, sessionId, content, options) {
   await client.createAgentActivity({
     agentSessionId: sessionId,
-    content
+    content,
+    ...options?.ephemeral ? { ephemeral: true } : {}
   });
 }
-async function postBodyActivity(client, sessionId, type, body) {
-  await postActivity(client, sessionId, { type, body });
+async function postBodyActivity(client, sessionId, type, body, options) {
+  await postActivity(client, sessionId, { type, body }, options);
 }
-async function postThought(client, sessionId, body) {
-  await postBodyActivity(client, sessionId, import_sdk.LinearDocument.AgentActivityType.Thought, body);
+async function postThought(client, sessionId, body, options) {
+  await postBodyActivity(client, sessionId, import_sdk.LinearDocument.AgentActivityType.Thought, body, options);
 }
-async function postError(client, sessionId, body) {
-  await postBodyActivity(client, sessionId, import_sdk.LinearDocument.AgentActivityType.Error, body);
+async function postError(client, sessionId, body, options) {
+  await postBodyActivity(client, sessionId, import_sdk.LinearDocument.AgentActivityType.Error, body, options);
 }
 async function postResponse(client, sessionId, body) {
   await postBodyActivity(client, sessionId, import_sdk.LinearDocument.AgentActivityType.Response, body);
@@ -120,14 +135,53 @@ async function postResponse(client, sessionId, body) {
 async function postElicitation(client, sessionId, body) {
   await postBodyActivity(client, sessionId, import_sdk.LinearDocument.AgentActivityType.Elicitation, body);
 }
-async function postAction(client, sessionId, body) {
+async function postSelectElicitation(client, sessionId, body, options) {
+  await postActivity(client, sessionId, {
+    type: import_sdk.LinearDocument.AgentActivityType.Elicitation,
+    body,
+    signal: import_sdk.LinearDocument.AgentActivitySignal.Select,
+    signalMetadata: { options }
+  });
+}
+async function postAuthElicitation(client, sessionId, body, url, provider) {
+  await postActivity(client, sessionId, {
+    type: import_sdk.LinearDocument.AgentActivityType.Elicitation,
+    body,
+    signal: import_sdk.LinearDocument.AgentActivitySignal.Auth,
+    signalMetadata: {
+      url,
+      ...provider ? { provider } : {}
+    }
+  });
+}
+async function postAction(client, sessionId, body, options) {
   await postActivity(client, sessionId, {
     type: import_sdk.LinearDocument.AgentActivityType.Action,
     action: body,
     parameter: ""
-  });
+  }, options);
 }
+var PLAN_STATUS_MAP = {
+  pending: "pending",
+  in_progress: "inProgress",
+  completed: "completed",
+  failed: "canceled"
+};
 async function updatePlan(client, sessionId, steps) {
+  if (typeof client.updateAgentSession === "function") {
+    const plan = {
+      steps: steps.map((step) => ({
+        content: step.title,
+        status: PLAN_STATUS_MAP[step.status]
+      }))
+    };
+    try {
+      await client.updateAgentSession(sessionId, { plan });
+      return;
+    } catch (err) {
+      console.warn("updateAgentSession failed, falling back to legacy plan", err);
+    }
+  }
   const planSummary = steps.map((step) => {
     const icon = step.status === "completed" ? "\u2705" : step.status === "in_progress" ? "\u23F3" : step.status === "failed" ? "\u274C" : "\u2B1C";
     return `${icon} ${step.title}`;
@@ -139,6 +193,141 @@ ${planSummary}`
   });
 }
 
+// src/integrations/linear/types.ts
+var STALE_SESSION_CHECK_INTERVAL_MS = 20 * 6e4;
+var STALE_SESSION_THRESHOLD_MS = 25 * 6e4;
+
+// src/integrations/linear/stale-session-guard.ts
+var DEFAULT_KEEPALIVE_MESSAGE = "Still working \u2014 waiting for specialist output in the collaboration room.";
+var StaleSessionGuard = class {
+  store;
+  linearClient;
+  logger;
+  checkIntervalMs;
+  staleThresholdMs;
+  keepAliveMessage;
+  timer = null;
+  constructor(options) {
+    this.store = options.store;
+    this.linearClient = options.linearClient;
+    this.logger = options.logger ?? new NoopLogger();
+    this.checkIntervalMs = options.checkIntervalMs ?? STALE_SESSION_CHECK_INTERVAL_MS;
+    this.staleThresholdMs = options.staleThresholdMs ?? STALE_SESSION_THRESHOLD_MS;
+    this.keepAliveMessage = options.keepAliveMessage ?? DEFAULT_KEEPALIVE_MESSAGE;
+  }
+  /** Start the periodic keepalive check. Safe to call multiple times. */
+  start() {
+    if (this.timer) {
+      return;
+    }
+    this.logger.info("stale_session_guard.started", {
+      checkIntervalMs: this.checkIntervalMs,
+      staleThresholdMs: this.staleThresholdMs
+    });
+    this.timer = setInterval(() => {
+      void this.tick();
+    }, this.checkIntervalMs);
+    if (typeof this.timer === "object" && "unref" in this.timer) {
+      this.timer.unref();
+    }
+  }
+  /** Stop the periodic keepalive check. */
+  stop() {
+    if (!this.timer) {
+      return;
+    }
+    clearInterval(this.timer);
+    this.timer = null;
+    this.logger.info("stale_session_guard.stopped", {});
+  }
+  /** Run a single keepalive check. Exposed for testing and manual invocation. */
+  async tick() {
+    if (!this.store.listActiveSessions) {
+      this.logger.warn("stale_session_guard.store_missing_listActiveSessions", {});
+      return 0;
+    }
+    let sessions;
+    try {
+      sessions = await this.store.listActiveSessions();
+    } catch (error) {
+      this.logger.error("stale_session_guard.list_sessions_failed", {
+        error: error instanceof Error ? error.message : String(error)
+      });
+      return 0;
+    }
+    const now = Date.now();
+    let kept = 0;
+    for (const session of sessions) {
+      if (isSessionStale(session, now, this.staleThresholdMs)) {
+        try {
+          await postThought(this.linearClient, session.linearSessionId, this.keepAliveMessage);
+          const activityTimestamp = (/* @__PURE__ */ new Date()).toISOString();
+          await this.store.upsert({
+            ...session,
+            lastLinearActivityAt: activityTimestamp,
+            updatedAt: activityTimestamp
+          });
+          kept += 1;
+          this.logger.info("stale_session_guard.keepalive_sent", {
+            sessionId: session.linearSessionId,
+            lastLinearActivityAt: session.lastLinearActivityAt
+          });
+        } catch (error) {
+          this.logger.warn("stale_session_guard.keepalive_failed", {
+            sessionId: session.linearSessionId,
+            error: error instanceof Error ? error.message : String(error)
+          });
+        }
+      }
+    }
+    if (kept > 0) {
+      this.logger.info("stale_session_guard.tick_complete", {
+        totalSessions: sessions.length,
+        keepalivesSent: kept
+      });
+    }
+    return kept;
+  }
+};
+function isSessionStale(session, nowMs, thresholdMs) {
+  const referenceIso = session.lastLinearActivityAt ?? session.updatedAt;
+  const referenceMs = new Date(referenceIso).getTime();
+  if (Number.isNaN(referenceMs)) {
+    return true;
+  }
+  return nowMs - referenceMs >= thresholdMs;
+}
+async function sendRecoveryActivityIfStale(input) {
+  const thresholdMs = input.staleThresholdMs ?? STALE_SESSION_THRESHOLD_MS;
+  if (!isSessionStale(input.session, Date.now(), thresholdMs)) {
+    return false;
+  }
+  try {
+    await postThought(
+      input.linearClient,
+      input.session.linearSessionId,
+      "Resuming session \u2014 reconnecting after extended specialist work."
+    );
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    await input.store.upsert({
+      ...input.session,
+      lastLinearActivityAt: now,
+      updatedAt: now
+    });
+    input.logger.info("stale_session_guard.recovery_activity_sent", {
+      sessionId: input.session.linearSessionId,
+      lastLinearActivityAt: input.session.lastLinearActivityAt
+    });
+    return true;
+  } catch (error) {
+    input.logger.warn("stale_session_guard.recovery_activity_failed", {
+      sessionId: input.session.linearSessionId,
+      error: error instanceof Error ? error.message : String(error)
+    });
+    return false;
+  }
+}
+
 // src/integrations/linear/bridge/message.ts
 function buildBridgeMessage(input) {
   const header = input.action === "created" ? "[Linear]: Agent session created." : "[Linear]: Agent session updated.";
@@ -158,6 +347,8 @@ function buildBridgeMessage(input) {
   const issueStateTypeLine = input.issueStateType ? `issue_state_type: ${input.issueStateType}` : "issue_state_type: none";
   const issueAssigneeLine = input.issueAssigneeName ? `issue_assignee: ${input.issueAssigneeName}` : "issue_assignee: none";
   const issueAssigneeIdLine = input.issueAssigneeId ? `issue_assignee_id: ${input.issueAssigneeId}` : "issue_assignee_id: none";
+  const issueDelegateLine = input.issueDelegateName ? `issue_delegate: ${input.issueDelegateName}` : "issue_delegate: none";
+  const issueDelegateIdLine = input.issueDelegateId ? `issue_delegate_id: ${input.issueDelegateId}` : "issue_delegate_id: none";
   const sessionStatusLine = input.sessionStatus ? `session_status: ${input.sessionStatus}` : "session_status: none";
   const sessionTypeLine = input.sessionType ? `session_type: ${input.sessionType}` : "session_type: none";
   const sessionCreatedLine = input.sessionCreatedAt ? `session_created_at: ${input.sessionCreatedAt}` : "session_created_at: none";
@@ -193,6 +384,8 @@ Linear session context:
 - ${issueStateTypeLine}
 - ${issueAssigneeLine}
 - ${issueAssigneeIdLine}
+- ${issueDelegateLine}
+- ${issueDelegateIdLine}
 - inferred_session_intent: ${input.sessionIntent}
 - writeback_mode: ${input.writebackMode}
 - ${appUserLine}
@@ -208,7 +401,7 @@ Bridge responsibilities:
 - keep Linear updated with meaningful milestones
 - use linear_post_thought and linear_post_action for meaningful progress updates
 - call linear_post_response when the work is actually finished
-- when you delegate inside Thenvoi, include the relevant ticket context in the room message so the specialist can act without hidden state
+- when you delegate inside Band, include the relevant ticket context in the room message so the specialist can act without hidden state
 
 Suggested peers available in the registry right now. They are not in the room yet:
 ${suggestedPeersLine}
@@ -278,6 +471,11 @@ function extractIssueAssigneeField(issue, field) {
   const value = assignee?.[field];
   return typeof value === "string" ? value : null;
 }
+function extractIssueDelegateField(issue, field) {
+  const delegate = extractNestedRecord(issue, "delegate");
+  const value = delegate?.[field];
+  return typeof value === "string" ? value : null;
+}
 function firstNonEmpty(...values) {
   for (const value of values) {
     if (!value) {
@@ -300,11 +498,13 @@ function extractRecord(value) {
 }
 
 // src/integrations/linear/bridge/handler.ts
+var DEFAULT_APP_BASE_URL = "https://app.band.ai";
 var SUPPORTED_ACTIONS = /* @__PURE__ */ new Set(["created", "updated", "canceled", "prompted"]);
 var MAX_PEER_LOOKUP_PAGES = 25;
 var PEER_PAGE_SIZE = 100;
 var RECOVERED_ROOM_EVENT_RETRY_LIMIT = 2;
 var RECOVERED_ROOM_EVENT_RETRY_BASE_DELAY_MS = 1e3;
+var AUTO_START_ELIGIBLE_TYPES = /* @__PURE__ */ new Set(["backlog", "unstarted", "triage"]);
 function createLinearBridgeRuntime() {
   return {
     roomResolutionLocks: /* @__PURE__ */ new Map(),
@@ -369,9 +569,19 @@ async function handleAgentSessionEvent(input, options) {
     });
     return;
   }
+  if (action === "updated" && existingBySession) {
+    await sendRecoveryActivityIfStale({
+      session: existingBySession,
+      linearClient: input.deps.linearClient,
+      store: input.deps.store,
+      logger
+    });
+  }
+  let lastLinearActivityAt = null;
   if (action === "created" && !options?.skipAcknowledgment) {
     try {
       await postThought(input.deps.linearClient, sessionId, "Received session. Setting up workspace...");
+      lastLinearActivityAt = (/* @__PURE__ */ new Date()).toISOString();
     } catch (ackError) {
       logger.warn("linear_thenvoi_bridge.acknowledgment_failed", {
         sessionId,
@@ -379,17 +589,59 @@ async function handleAgentSessionEvent(input, options) {
       });
     }
   }
+  let delegatePromise;
+  if (action === "created" && issueId) {
+    const appUserId = input.payload.appUserId;
+    if (appUserId) {
+      delegatePromise = trySetAgentAsDelegate({
+        linearClient: input.deps.linearClient,
+        issueId,
+        appUserId,
+        logger
+      }).catch((delegateError) => {
+        logger.warn("linear_thenvoi_bridge.auto_delegate_failed", {
+          sessionId,
+          issueId,
+          appUserId,
+          error: delegateError instanceof Error ? delegateError.message : String(delegateError)
+        });
+        return { set: false, delegateName: null };
+      });
+    }
+  }
+  let autoStartPromise;
+  if (action === "created" && issueId) {
+    const originalStateType = extractIssueStateField(input.payload.agentSession.issue, "type");
+    const teamId = extractIssueTeamId(input.payload.agentSession.issue);
+    if (teamId && originalStateType && AUTO_START_ELIGIBLE_TYPES.has(originalStateType)) {
+      autoStartPromise = tryMoveIssueToStarted({
+        linearClient: input.deps.linearClient,
+        issueId,
+        teamId,
+        logger
+      }).catch((autoStartError) => {
+        logger.warn("linear_thenvoi_bridge.auto_start_failed", {
+          sessionId,
+          issueId,
+          teamId,
+          error: autoStartError instanceof Error ? autoStartError.message : String(autoStartError)
+        });
+        return { moved: false, stateId: null, stateName: null };
+      });
+    }
+  }
   let roomRecord = null;
+  let externalUrlPromise;
   try {
     const hostAgentHandle = await resolveHostAgentHandle({
-      thenvoiRest: input.deps.thenvoiRest,
+      bandRest: input.deps.bandRest,
       configuredHostHandle: config.hostAgentHandle,
       logger,
       runtime
     });
     const existingByIssue = config.roomStrategy === "issue" && issueId ? await input.deps.store.getByIssueId(issueId) : null;
     roomRecord = await resolveRoomRecord({
-      thenvoiRest: input.deps.thenvoiRest,
+      bandRest: input.deps.bandRest,
       store: input.deps.store,
       roomStrategy: config.roomStrategy,
       sessionId,
@@ -397,6 +649,22 @@ async function handleAgentSessionEvent(input, options) {
       logger,
       runtime
     });
+    if (action === "created") {
+      const roomId = roomRecord.bandRoomId;
+      externalUrlPromise = trySetSessionExternalUrl({
+        linearClient: input.deps.linearClient,
+        sessionId,
+        roomId,
+        appBaseUrl: config.bandAppBaseUrl,
+        logger
+      }).catch((urlError) => {
+        logger.warn("linear_thenvoi_bridge.set_external_url_failed", {
+          sessionId,
+          roomId,
+          error: urlError instanceof Error ? urlError.message : String(urlError)
+        });
+      });
+    }
     const sessionIntent = detectSessionIntent({
       issueStateType: extractIssueStateField(input.payload.agentSession.issue, "type"),
       promptContext: input.payload.promptContext,
@@ -405,8 +673,8 @@ async function handleAgentSessionEvent(input, options) {
       issueDescription: input.payload.agentSession.issue?.description
     });
     const suggestedPeerHandles = await selectRelevantPeerHandles({
-      thenvoiRest: input.deps.thenvoiRest,
-      roomId: roomRecord.thenvoiRoomId,
+      bandRest: input.deps.bandRest,
+      roomId: roomRecord.bandRoomId,
       intent: sessionIntent,
       hostAgentHandle,
       planningAgentHandles: input.config.planningAgentHandles,
@@ -414,11 +682,27 @@ async function handleAgentSessionEvent(input, options) {
       logger
     });
     await ensureRoomParticipants({
-      thenvoiRest: input.deps.thenvoiRest,
-      roomId: roomRecord.thenvoiRoomId,
+      bandRest: input.deps.bandRest,
+      roomId: roomRecord.bandRoomId,
       handles: [hostAgentHandle],
       logger
     });
+    const delegateResult = await delegatePromise;
+    let issueDelegateId = extractIssueDelegateField(input.payload.agentSession.issue, "id");
+    let issueDelegateName = extractIssueDelegateField(input.payload.agentSession.issue, "displayName") ?? extractIssueDelegateField(input.payload.agentSession.issue, "name");
+    if (delegateResult?.set && input.payload.appUserId) {
+      issueDelegateId = input.payload.appUserId;
+      issueDelegateName = delegateResult.delegateName ?? input.payload.appUserId;
+    }
+    const autoStartResult = await autoStartPromise;
+    let issueStateId = extractIssueStateField(input.payload.agentSession.issue, "id");
+    let issueStateName = extractIssueStateField(input.payload.agentSession.issue, "name");
+    let resolvedStateType = extractIssueStateField(input.payload.agentSession.issue, "type");
+    if (autoStartResult?.moved) {
+      if (autoStartResult.stateId) issueStateId = autoStartResult.stateId;
+      if (autoStartResult.stateName) issueStateName = autoStartResult.stateName;
+      resolvedStateType = "started";
+    }
     const message = buildBridgeMessage({
       sessionId,
       issueId,
@@ -436,11 +720,13 @@ async function handleAgentSessionEvent(input, options) {
       issueTeamKey: extractIssueTeamKey(input.payload.agentSession.issue),
       issueTeamName: extractIssueTeamName(input.payload.agentSession.issue),
       issueTeamId: extractIssueTeamId(input.payload.agentSession.issue),
-      issueStateId: extractIssueStateField(input.payload.agentSession.issue, "id"),
-      issueStateName: extractIssueStateField(input.payload.agentSession.issue, "name"),
-      issueStateType: extractIssueStateField(input.payload.agentSession.issue, "type"),
+      issueStateId,
+      issueStateName,
+      issueStateType: resolvedStateType,
       issueAssigneeId: extractIssueAssigneeField(input.payload.agentSession.issue, "id"),
       issueAssigneeName: extractIssueAssigneeField(input.payload.agentSession.issue, "displayName") ?? extractIssueAssigneeField(input.payload.agentSession.issue, "name"),
+      issueDelegateId,
+      issueDelegateName,
       commentBody: input.payload.agentSession.comment?.body,
       commentId: input.payload.agentSession.comment?.id,
       sessionIntent,
@@ -458,17 +744,17 @@ async function handleAgentSessionEvent(input, options) {
       linear_issue_id: issueId,
       linear_prompt_context: input.payload.promptContext ?? null,
       linear_writeback_mode: config.writebackMode,
-      linear_bridge: "thenvoi",
+      linear_bridge: "band",
       linear_host_handle: hostAgentHandle
     };
     const shouldResetRoomSession = Boolean(
-      existingByIssue && existingByIssue.linearSessionId !== sessionId && existingByIssue.thenvoiRoomId === roomRecord.thenvoiRoomId && (existingByIssue.status === "completed" || existingByIssue.status === "errored")
+      existingByIssue && existingByIssue.linearSessionId !== sessionId && existingByIssue.bandRoomId === roomRecord.bandRoomId && (existingByIssue.status === "completed" || existingByIssue.status === "errored")
     );
-    const authenticatedHostHandle = runtime.authenticatedHostHandleCache.get(input.deps.thenvoiRest) ?? null;
+    const authenticatedHostHandle = runtime.authenticatedHostHandleCache.get(input.deps.bandRest) ?? null;
     const canBootstrapDirectly = options?.skipRoomWrite === true || authenticatedHostHandle === null || authenticatedHostHandle === hostAgentHandle;
     if (!options?.skipRoomWrite || !canBootstrapDirectly) {
       roomRecord = await forwardBridgeMessage({
-        thenvoiRest: input.deps.thenvoiRest,
+        bandRest: input.deps.bandRest,
         store: input.deps.store,
         logger,
         roomRecord,
@@ -486,7 +772,7 @@ async function handleAgentSessionEvent(input, options) {
       await enqueueBootstrapRequest(input.deps.store, {
         eventKey,
         linearSessionId: sessionId,
-        thenvoiRoomId: roomRecord.thenvoiRoomId,
+        bandRoomId: roomRecord.bandRoomId,
         expectedContent: message,
         messageType: "task",
         senderId: linearActor.id,
@@ -497,19 +783,25 @@ async function handleAgentSessionEvent(input, options) {
         } : messageMetadata
       });
     }
+    const now = (/* @__PURE__ */ new Date()).toISOString();
     await saveSessionRecord(input.deps.store, {
       ...roomRecord,
       status: "active",
       lastEventKey: eventKey,
-      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+      lastLinearActivityAt: lastLinearActivityAt ?? roomRecord.lastLinearActivityAt ?? now,
+      updatedAt: now
     });
+    await externalUrlPromise;
     logger.info("linear_thenvoi_bridge.message_forwarded", {
       sessionId,
       issueId,
-      roomId: roomRecord.thenvoiRoomId,
+      roomId: roomRecord.bandRoomId,
       action
     });
   } catch (error) {
+    await externalUrlPromise;
+    await delegatePromise;
+    await autoStartPromise;
     try {
       await postError(
         input.deps.linearClient,
@@ -555,18 +847,39 @@ async function completeLinearSession(input) {
   if (!existing) {
     return;
   }
+  const now = (/* @__PURE__ */ new Date()).toISOString();
   await saveSessionRecord(input.store, {
     ...existing,
     status: "completed",
     lastEventKey: input.lastEventKey ?? existing.lastEventKey ?? null,
-    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    lastLinearActivityAt: now,
+    updatedAt: now
+  });
+}
+async function trySetSessionExternalUrl(input) {
+  if (typeof input.linearClient.agentSessionUpdateExternalUrl !== "function") {
+    input.logger.info("linear_thenvoi_bridge.set_external_url_skipped_no_api", {
+      sessionId: input.sessionId
+    });
+    return;
+  }
+  const base = input.appBaseUrl.replace(/\/+$/, "");
+  const roomUrl = `${base}/rooms/${input.roomId}`;
+  await input.linearClient.agentSessionUpdateExternalUrl(input.sessionId, {
+    externalUrls: [{ label: "View in Band", url: roomUrl }]
+  });
+  input.logger.info("linear_thenvoi_bridge.external_url_set", {
+    sessionId: input.sessionId,
+    roomId: input.roomId,
+    url: roomUrl
   });
 }
 function normalizeConfig(config) {
   return {
     roomStrategy: config.roomStrategy ?? "issue",
     writebackMode: config.writebackMode ?? "final_only",
-    hostAgentHandle: normalizeOptionalHandle(config.hostAgentHandle)
+    hostAgentHandle: normalizeOptionalHandle(config.hostAgentHandle),
+    bandAppBaseUrl: config.bandAppBaseUrl ?? DEFAULT_APP_BASE_URL
   };
 }
 function normalizeOptionalHandle(handle) {
@@ -576,25 +889,82 @@ function normalizeOptionalHandle(handle) {
   const normalized = stripHandlePrefix(handle);
   return normalized.length > 0 ? normalized : null;
 }
+async function trySetAgentAsDelegate(input) {
+  const issue = await input.linearClient.issue(input.issueId);
+  const existingDelegateId = issue.delegateId;
+  if (existingDelegateId) {
+    input.logger.info("linear_thenvoi_bridge.delegate_already_set", {
+      issueId: input.issueId,
+      existingDelegateId
+    });
+    return { set: false, delegateName: null };
+  }
+  await input.linearClient.updateIssue(input.issueId, {
+    delegateId: input.appUserId
+  });
+  let delegateName = null;
+  try {
+    const updated = await input.linearClient.issue(input.issueId);
+    const delegate = await updated.delegate;
+    delegateName = delegate?.displayName ?? delegate?.name ?? null;
+  } catch {
+  }
+  input.logger.info("linear_thenvoi_bridge.delegate_set", {
+    issueId: input.issueId,
+    delegateId: input.appUserId
+  });
+  return { set: true, delegateName };
+}
+async function tryMoveIssueToStarted(input) {
+  const response = await input.linearClient.workflowStates({
+    filter: {
+      team: { id: { eq: input.teamId } },
+      type: { eq: "started" }
+    }
+  });
+  const nodes = Array.isArray(response.nodes) ? response.nodes : [];
+  const startedStates = [...nodes].sort((a, b) => a.position - b.position);
+  const targetState = startedStates[0];
+  if (!targetState?.id) {
+    input.logger.info("linear_thenvoi_bridge.auto_start_no_started_state", {
+      issueId: input.issueId,
+      teamId: input.teamId
+    });
+    return { moved: false, stateId: null, stateName: null };
+  }
+  await input.linearClient.updateIssue(input.issueId, {
+    stateId: targetState.id
+  });
+  input.logger.info("linear_thenvoi_bridge.auto_start_moved", {
+    issueId: input.issueId,
+    stateId: targetState.id,
+    stateName: targetState.name ?? null
+  });
+  return {
+    moved: true,
+    stateId: targetState.id,
+    stateName: targetState.name ?? null
+  };
+}
 async function resolveHostAgentHandle(input) {
   if (input.configuredHostHandle) {
-    input.runtime.resolvedHostHandleCache.set(input.thenvoiRest, input.configuredHostHandle);
+    input.runtime.resolvedHostHandleCache.set(input.bandRest, input.configuredHostHandle);
     return input.configuredHostHandle;
   }
-  const cachedAuthenticated = input.runtime.authenticatedHostHandleCache.get(input.thenvoiRest);
+  const cachedAuthenticated = input.runtime.authenticatedHostHandleCache.get(input.bandRest);
   if (cachedAuthenticated) {
-    input.runtime.resolvedHostHandleCache.set(input.thenvoiRest, cachedAuthenticated);
+    input.runtime.resolvedHostHandleCache.set(input.bandRest, cachedAuthenticated);
     return cachedAuthenticated;
   }
-  const cached = input.runtime.resolvedHostHandleCache.get(input.thenvoiRest);
+  const cached = input.runtime.resolvedHostHandleCache.get(input.bandRest);
   if (cached) {
     return cached;
   }
-  const identity = await input.thenvoiRest.getAgentMe();
+  const identity = await input.bandRest.getAgentMe();
   const authenticatedAgentHandle = normalizeOptionalHandle(identity.handle);
   if (authenticatedAgentHandle) {
-    input.runtime.authenticatedHostHandleCache.set(input.thenvoiRest, authenticatedAgentHandle);
-    input.runtime.resolvedHostHandleCache.set(input.thenvoiRest, authenticatedAgentHandle);
+    input.runtime.authenticatedHostHandleCache.set(input.bandRest, authenticatedAgentHandle);
+    input.runtime.resolvedHostHandleCache.set(input.bandRest, authenticatedAgentHandle);
     return authenticatedAgentHandle;
   }
   throw new Error(
@@ -628,14 +998,14 @@ async function handleCanceledAction(input) {
     updatedAt: (/* @__PURE__ */ new Date()).toISOString()
   });
   if (!input.skipRoomWrite) {
-    await input.deps.thenvoiRest.createChatEvent(existing.thenvoiRoomId, {
+    await input.deps.bandRest.createChatEvent(existing.bandRoomId, {
       content: "[Linear]: Agent session canceled. Stop in-room execution and await new instructions.",
       messageType: "task",
       metadata: {
         linear_event_action: "canceled",
         linear_session_id: input.sessionId,
         linear_issue_id: input.issueId,
-        linear_bridge: "thenvoi"
+        linear_bridge: "band"
       }
     });
   }
@@ -661,15 +1031,21 @@ async function handlePromptedAction(input) {
     });
     return;
   }
+  await sendRecoveryActivityIfStale({
+    session: existing,
+    linearClient: input.deps.linearClient,
+    store: input.deps.store,
+    logger: input.logger
+  });
   const message = `[Linear User Response]: ${userResponse}`;
   const metadata = {
     linear_event_action: "prompted",
     linear_session_id: input.sessionId,
-    linear_bridge: "thenvoi"
+    linear_bridge: "band"
   };
-  const canBootstrapDirectly = input.config.hostAgentHandle !== null ? true : Boolean(normalizeOptionalHandle((await input.deps.thenvoiRest.getAgentMe()).handle));
+  const canBootstrapDirectly = input.config.hostAgentHandle !== null ? true : Boolean(normalizeOptionalHandle((await input.deps.bandRest.getAgentMe()).handle));
   if (!input.skipRoomWrite || !canBootstrapDirectly) {
-    await input.deps.thenvoiRest.createChatEvent(existing.thenvoiRoomId, {
+    await input.deps.bandRest.createChatEvent(existing.bandRoomId, {
       content: message,
       messageType: "text",
       metadata
@@ -680,7 +1056,7 @@ async function handlePromptedAction(input) {
     await enqueueBootstrapRequest(input.deps.store, {
       eventKey: input.eventKey,
       linearSessionId: input.sessionId,
-      thenvoiRoomId: existing.thenvoiRoomId,
+      bandRoomId: existing.bandRoomId,
       expectedContent: message,
       messageType: "text",
       senderId: linearActor.id,
@@ -696,7 +1072,7 @@ async function handlePromptedAction(input) {
   });
   input.logger.info("linear_thenvoi_bridge.prompted_forwarded", {
     sessionId: input.sessionId,
-    roomId: existing.thenvoiRoomId
+    roomId: existing.bandRoomId
   });
 }
 async function enqueueBootstrapRequest(store, request) {
@@ -738,7 +1114,7 @@ async function resolveRoomRecord(input) {
 }
 async function forwardBridgeMessage(input) {
   try {
-    await input.thenvoiRest.createChatEvent(input.roomRecord.thenvoiRoomId, {
+    await input.bandRest.createChatEvent(input.roomRecord.bandRoomId, {
       content: input.message,
       messageType: input.messageType,
       metadata: input.metadata
@@ -751,26 +1127,26 @@ async function forwardBridgeMessage(input) {
     input.logger.warn("linear_thenvoi_bridge.room_forward_recovering_with_fresh_room", {
       sessionId: input.sessionId,
       issueId: input.issueId,
-      previousRoomId: input.roomRecord.thenvoiRoomId,
+      previousRoomId: input.roomRecord.bandRoomId,
       error: error instanceof Error ? error.message : String(error)
     });
     const recoveredRoom = await createFreshRoomRecord({
-      thenvoiRest: input.thenvoiRest,
+      bandRest: input.bandRest,
       store: input.store,
       sessionId: input.sessionId,
       issueId: input.issueId,
       logger: input.logger
     });
     await ensureRoomParticipants({
-      thenvoiRest: input.thenvoiRest,
-      roomId: recoveredRoom.thenvoiRoomId,
+      bandRest: input.bandRest,
+      roomId: recoveredRoom.bandRoomId,
       handles: [input.hostAgentHandle],
       logger: input.logger
     });
     let attempt = 0;
     while (true) {
       try {
-        await input.thenvoiRest.createChatEvent(recoveredRoom.thenvoiRoomId, {
+        await input.bandRest.createChatEvent(recoveredRoom.bandRoomId, {
           content: input.message,
           messageType: input.messageType,
           metadata: input.metadata
@@ -786,7 +1162,7 @@ async function forwardBridgeMessage(input) {
         input.logger.warn("linear_thenvoi_bridge.room_recreated_retrying", {
           sessionId: input.sessionId,
           issueId: input.issueId,
-          roomId: recoveredRoom.thenvoiRoomId,
+          roomId: recoveredRoom.bandRoomId,
           attempt,
           delayMs,
           error: recoveredError instanceof Error ? recoveredError.message : String(recoveredError)
@@ -816,11 +1192,11 @@ function isRetryableRateLimitError(error) {
 }
 async function createFreshRoomRecord(input) {
   const now = (/* @__PURE__ */ new Date()).toISOString();
-  const created = await input.thenvoiRest.createChat();
+  const created = await input.bandRest.createChat();
   const record = {
     linearSessionId: input.sessionId,
     linearIssueId: input.issueId,
-    thenvoiRoomId: created.id,
+    bandRoomId: created.id,
     status: "active",
     lastEventKey: null,
     createdAt: now,
@@ -846,7 +1222,7 @@ async function resolveRoomRecordImpl(input) {
       const linkedRecord = {
         linearSessionId: input.sessionId,
         linearIssueId: input.issueId,
-        thenvoiRoomId: existingByIssue.thenvoiRoomId,
+        bandRoomId: existingByIssue.bandRoomId,
         status: "active",
         lastEventKey: existingBySession?.lastEventKey ?? null,
         createdAt: existingBySession?.createdAt ?? now2,
@@ -857,11 +1233,11 @@ async function resolveRoomRecordImpl(input) {
     }
   }
   const now = (/* @__PURE__ */ new Date()).toISOString();
-  const created = await input.thenvoiRest.createChat();
+  const created = await input.bandRest.createChat();
   const createdRecord = {
     linearSessionId: input.sessionId,
     linearIssueId: input.issueId,
-    thenvoiRoomId: created.id,
+    bandRoomId: created.id,
     status: "active",
     lastEventKey: null,
     createdAt: now,
@@ -882,7 +1258,7 @@ async function ensureRoomParticipants(input) {
   }
   let existingParticipants;
   try {
-    existingParticipants = await input.thenvoiRest.listChatParticipants(input.roomId);
+    existingParticipants = await input.bandRest.listChatParticipants(input.roomId);
   } catch (error) {
     if (isRetryableRateLimitError(error)) {
       input.logger.warn("linear_thenvoi_bridge.participant_list_rate_limited", {
@@ -902,7 +1278,7 @@ async function ensureRoomParticipants(input) {
   }
   let peersByHandle;
   try {
-    peersByHandle = await lookupPeerIdsByHandle(input.thenvoiRest, input.roomId, missingHandles);
+    peersByHandle = await lookupPeerIdsByHandle(input.bandRest, input.roomId, missingHandles);
   } catch (error) {
     if (error instanceof UnsupportedFeatureError) {
       input.logger.warn("linear_thenvoi_bridge.peer_lookup_unavailable", {
@@ -924,7 +1300,7 @@ async function ensureRoomParticipants(input) {
       continue;
     }
     try {
-      await input.thenvoiRest.addChatParticipant(
+      await input.bandRest.addChatParticipant(
         input.roomId,
         {
           participantId,
@@ -943,14 +1319,14 @@ async function ensureRoomParticipants(input) {
     }
   }
 }
-async function lookupPeerIdsByHandle(thenvoiRest, roomId, handles) {
-  if (!thenvoiRest.listPeers) {
+async function lookupPeerIdsByHandle(bandRest, roomId, handles) {
+  if (!bandRest.listPeers) {
     throw new UnsupportedFeatureError("Peer listing is not available in current REST adapter");
   }
   const targets = new Set(handles);
   const found = /* @__PURE__ */ new Map();
   for (let page = 1; page <= MAX_PEER_LOOKUP_PAGES && found.size < targets.size; page += 1) {
-    const response = await thenvoiRest.listPeers({
+    const response = await bandRest.listPeers({
       page,
       pageSize: PEER_PAGE_SIZE,
       notInChat: roomId
@@ -991,12 +1367,12 @@ async function selectRelevantPeerHandles(input) {
     });
     return configuredHandles;
   }
-  if (!input.thenvoiRest.listPeers) {
+  if (!input.bandRest.listPeers) {
     return [];
   }
   let peers;
   try {
-    const response = await input.thenvoiRest.listPeers({
+    const response = await input.bandRest.listPeers({
       page: 1,
       pageSize: PEER_PAGE_SIZE,
       notInChat: input.roomId
@@ -1127,6 +1503,7 @@ var SqliteSessionRoomStore = class {
           thenvoi_room_id,
           status,
           last_event_key,
+          last_linear_activity_at,
           created_at,
           updated_at
         FROM linear_thenvoi_session_rooms
@@ -1147,6 +1524,7 @@ var SqliteSessionRoomStore = class {
           thenvoi_room_id,
           status,
           last_event_key,
+          last_linear_activity_at,
           created_at,
           updated_at
         FROM linear_thenvoi_session_rooms
@@ -1168,23 +1546,26 @@ var SqliteSessionRoomStore = class {
           thenvoi_room_id,
           status,
           last_event_key,
+          last_linear_activity_at,
           created_at,
           updated_at
-        ) VALUES (?, ?, ?, ?, ?, ?, ?)
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)
         ON CONFLICT(linear_session_id)
         DO UPDATE SET
           linear_issue_id = excluded.linear_issue_id,
           thenvoi_room_id = excluded.thenvoi_room_id,
           status = excluded.status,
           last_event_key = excluded.last_event_key,
+          last_linear_activity_at = excluded.last_linear_activity_at,
           updated_at = excluded.updated_at
         `
     ).run(
       record.linearSessionId,
       record.linearIssueId,
-      record.thenvoiRoomId,
+      record.bandRoomId,
       record.status,
       record.lastEventKey ?? null,
+      record.lastLinearActivityAt ?? null,
       record.createdAt,
       record.updatedAt
     );
@@ -1228,7 +1609,7 @@ var SqliteSessionRoomStore = class {
     ).run(
       request.eventKey,
       request.linearSessionId,
-      request.thenvoiRoomId,
+      request.bandRoomId,
       request.expectedContent,
       request.messageType,
       request.metadata ? JSON.stringify(request.metadata) : null,
@@ -1260,7 +1641,7 @@ var SqliteSessionRoomStore = class {
     return rows.map((row) => ({
       eventKey: row.event_key,
       linearSessionId: row.linear_session_id,
-      thenvoiRoomId: row.thenvoi_room_id,
+      bandRoomId: row.thenvoi_room_id,
       expectedContent: row.expected_content,
       messageType: row.message_type,
       metadata: this.parseMetadata(row.metadata_json),
@@ -1278,6 +1659,29 @@ var SqliteSessionRoomStore = class {
         `
     ).run((/* @__PURE__ */ new Date()).toISOString(), eventKey);
   }
+  async listActiveSessions() {
+    const db = await this.getDb();
+    const rawRows = db.prepare(
+      `
+        SELECT
+          linear_session_id,
+          linear_issue_id,
+          thenvoi_room_id,
+          status,
+          last_event_key,
+          last_linear_activity_at,
+          created_at,
+          updated_at
+        FROM linear_thenvoi_session_rooms
+        WHERE status IN ('active', 'waiting')
+        ORDER BY updated_at DESC
+        `
+    ).all();
+    if (!Array.isArray(rawRows)) {
+      return [];
+    }
+    return rawRows.map((raw) => parseSessionRoomRow(raw)).filter((row) => row !== null).map((row) => this.toRecord(row));
+  }
   async close() {
     if (!this.dbPromise) {
       return;
@@ -1359,15 +1763,26 @@ var SqliteSessionRoomStore = class {
         throw error;
       }
     }
+    try {
+      db.exec(`
+        ALTER TABLE linear_thenvoi_session_rooms
+        ADD COLUMN last_linear_activity_at TEXT
+      `);
+    } catch (error) {
+      if (!isDuplicateColumnError(error)) {
+        throw error;
+      }
+    }
     return db;
   }
   toRecord(row) {
     return {
       linearSessionId: row.linear_session_id,
       linearIssueId: row.linear_issue_id,
-      thenvoiRoomId: row.thenvoi_room_id,
+      bandRoomId: row.thenvoi_room_id,
       status: row.status,
       lastEventKey: row.last_event_key,
+      lastLinearActivityAt: row.last_linear_activity_at,
       createdAt: row.created_at,
       updatedAt: row.updated_at
     };
@@ -1420,20 +1835,22 @@ function parseSessionRoomRow(value) {
   }
   const linearSessionId = asString(row.linear_session_id);
   const linearIssueId = asNullableString(row.linear_issue_id);
-  const thenvoiRoomId = asString(row.thenvoi_room_id);
+  const bandRoomId = asString(row.thenvoi_room_id);
   const status = asString(row.status);
   const lastEventKey = asNullableString(row.last_event_key);
+  const lastLinearActivityAt = asNullableString(row.last_linear_activity_at);
   const createdAt = asString(row.created_at);
   const updatedAt = asString(row.updated_at);
-  if (!linearSessionId || linearIssueId === void 0 || !thenvoiRoomId || !status || !isSessionStatus(status) || lastEventKey === void 0 || !createdAt || !updatedAt) {
+  if (!linearSessionId || linearIssueId === void 0 || !bandRoomId || !status || !isSessionStatus(status) || lastEventKey === void 0 || lastLinearActivityAt === void 0 || !createdAt || !updatedAt) {
     return null;
   }
   return {
     linear_session_id: linearSessionId,
     linear_issue_id: linearIssueId,
-    thenvoi_room_id: thenvoiRoomId,
+    thenvoi_room_id: bandRoomId,
     status,
     last_event_key: lastEventKey,
+    last_linear_activity_at: lastLinearActivityAt,
     created_at: createdAt,
     updated_at: updatedAt
   };
@@ -1451,20 +1868,20 @@ function parseBootstrapRequestRow(value) {
   }
   const eventKey = asString(row.event_key);
   const linearSessionId = asString(row.linear_session_id);
-  const thenvoiRoomId = asString(row.thenvoi_room_id);
+  const bandRoomId = asString(row.thenvoi_room_id);
   const expectedContent = asString(row.expected_content);
   const messageType = asString(row.message_type);
   const metadataJson = asNullableString(row.metadata_json);
   const createdAt = asString(row.created_at);
   const expiresAt = asString(row.expires_at);
   const processedAt = asNullableString(row.processed_at);
-  if (!eventKey || !linearSessionId || !thenvoiRoomId || !expectedContent || !messageType || metadataJson === void 0 || !createdAt || !expiresAt || processedAt === void 0) {
+  if (!eventKey || !linearSessionId || !bandRoomId || !expectedContent || !messageType || metadataJson === void 0 || !createdAt || !expiresAt || processedAt === void 0) {
     return null;
   }
   return {
     event_key: eventKey,
     linear_session_id: linearSessionId,
-    thenvoi_room_id: thenvoiRoomId,
+    thenvoi_room_id: bandRoomId,
     expected_content: expectedContent,
     message_type: messageType,
     metadata_json: metadataJson,
@@ -1479,8 +1896,18 @@ function createSqliteSessionRoomStore(dbPath) {
 
 // src/integrations/linear/tools.ts
 var import_zod = require("zod");
+var LOCALHOST_HOSTNAMES = /* @__PURE__ */ new Set(["localhost", "127.0.0.1", "[::1]"]);
+function isAllowedAuthUrl(u) {
+  try {
+    const parsed = new URL(u);
+    if (parsed.protocol === "https:") return true;
+    return LOCALHOST_HOSTNAMES.has(parsed.hostname);
+  } catch {
+    return false;
+  }
+}
 function createLinearTools(options) {
-  const { client, store, enableElicitation = true } = options;
+  const { client, store, enableElicitation = true, logger } = options;
   const sessionBodySchema = import_zod.z.object({
     session_id: import_zod.z.string().describe("The Linear agent session ID"),
     body: import_zod.z.string().describe("The message body in Markdown format")
@@ -1492,52 +1919,121 @@ function createLinearTools(options) {
   const requiredIssueIdSchema = issueIdInputSchema;
   const optionalIssueIdSchema = issueIdInputSchema;
   const tools = [];
-  const addSessionBodyTool = (name, description, handler) => {
+  const ephemeralSessionBodySchema = sessionBodySchema.extend({
+    ephemeral: import_zod.z.boolean().optional().describe(
+      'If true, this activity is displayed temporarily and replaced when the next activity arrives. Use for transient status indicators like "Thinking...", "Searching...", or "Waiting for response...".'
+    )
+  });
+  const addSessionBodyTool = (name, description, activityFn, options2) => {
+    const supportsEphemeral = options2?.supportsEphemeral ?? false;
     tools.push({
       name,
-      description,
-      schema: sessionBodySchema,
-      handler
+      description: supportsEphemeral ? description + " Set ephemeral: true for transient status updates that should disappear when the next activity arrives." : description,
+      schema: supportsEphemeral ? ephemeralSessionBodySchema : sessionBodySchema,
+      handler: async (args) => {
+        await activityFn(
+          client,
+          args.session_id,
+          args.body,
+          supportsEphemeral && args.ephemeral === true ? { ephemeral: true } : void 0
+        );
+        return { ok: true };
+      }
     });
   };
   addSessionBodyTool(
     "linear_post_thought",
     "Post a thought to the Linear agent session, visible to the user as internal reasoning.",
-    async (args) => {
-      await postThought(client, args.session_id, args.body);
-      return { ok: true };
-    }
+    postThought,
+    { supportsEphemeral: true }
   );
   addSessionBodyTool(
     "linear_post_action",
     "Post an action to the Linear agent session, showing the user what step is being taken.",
-    async (args) => {
-      await postAction(client, args.session_id, args.body);
-      return { ok: true };
-    }
+    postAction,
+    { supportsEphemeral: true }
   );
   addSessionBodyTool(
     "linear_post_error",
     "Post an error to the Linear agent session to notify the user of a failure.",
-    async (args) => {
-      await postError(client, args.session_id, args.body);
-      return { ok: true };
-    }
+    postError
   );
   if (enableElicitation) {
-    addSessionBodyTool(
-      "linear_ask_user",
-      "Ask the Linear user a question via an elicitation activity.",
-      async (args) => {
-        await postElicitation(client, args.session_id, args.body);
+    tools.push({
+      name: "linear_ask_user",
+      description: "Ask the Linear user a question. When options are provided, Linear renders them as a clickable picker (select signal); otherwise the user sees a free-text prompt.",
+      schema: import_zod.z.object({
+        session_id: import_zod.z.string().describe("The Linear agent session ID"),
+        body: import_zod.z.string().max(ELICITATION_BODY_MAX_LENGTH).describe("The question to ask, in Markdown format"),
+        options: import_zod.z.array(import_zod.z.object({
+          label: import_zod.z.string().max(SELECT_OPTION_MAX_LENGTH).describe("Display text for the option"),
+          value: import_zod.z.string().max(SELECT_OPTION_MAX_LENGTH).describe("Value returned when the option is selected")
+        })).min(2).max(20).optional().describe("Clickable options for a select picker (2\u201320 items). Omit for free-text input.")
+      }),
+      handler: async (args) => {
+        const sessionId = args.session_id;
+        const body = args.body;
+        const options2 = args.options;
+        if (options2) {
+          await postSelectElicitation(client, sessionId, body, options2);
+        } else {
+          await postElicitation(client, sessionId, body);
+        }
         return { ok: true };
       }
-    );
+    });
+    tools.push({
+      name: "linear_select",
+      description: "Present the Linear user with a set of clickable options via a select elicitation. Use this instead of linear_ask_user when the user should pick from a known list of choices.",
+      schema: import_zod.z.object({
+        session_id: import_zod.z.string().describe("The Linear agent session ID"),
+        body: import_zod.z.string().describe("The question or prompt shown above the options (Markdown)"),
+        options: import_zod.z.array(
+          import_zod.z.object({
+            label: import_zod.z.string().describe("Display label for this option"),
+            value: import_zod.z.string().describe("Value returned when this option is selected")
+          })
+        ).min(1).max(25).describe("The selectable options")
+      }),
+      handler: async (args) => {
+        await postSelectElicitation(
+          client,
+          args.session_id,
+          args.body,
+          args.options
+        );
+        return { ok: true };
+      }
+    });
+    tools.push({
+      name: "linear_request_auth",
+      description: "Ask the Linear user to link an external account by presenting an authentication button. The user sees a 'Link account' UI that opens the provided URL.",
+      schema: import_zod.z.object({
+        session_id: import_zod.z.string().describe("The Linear agent session ID"),
+        body: import_zod.z.string().max(ELICITATION_BODY_MAX_LENGTH).describe("Explanation of why authentication is needed, in Markdown format"),
+        url: import_zod.z.string().url().refine(
+          isAllowedAuthUrl,
+          { message: "URL must use https (http allowed only for localhost)" }
+        ).describe("The authentication URL to open when the user clicks the link button"),
+        provider: import_zod.z.string().min(1).max(PROVIDER_MAX_LENGTH).optional().describe("Name of the external service (e.g. 'GitHub', 'Slack')")
+      }),
+      handler: async (args) => {
+        await postAuthElicitation(
+          client,
+          args.session_id,
+          args.body,
+          args.url,
+          args.provider
+        );
+        return { ok: true };
+      }
+    });
   }
-  addSessionBodyTool(
-    "linear_post_response",
-    "Post the final response to the Linear agent session and mark the session completed when a store is available.",
-    async (args) => {
+  tools.push({
+    name: "linear_post_response",
+    description: "Post the final response to the Linear agent session and mark the session completed when a store is available.",
+    schema: sessionBodySchema,
+    handler: async (args) => {
       await completeLinearSession({
         linearClient: client,
         agentSessionId: args.session_id,
@@ -1546,11 +2042,11 @@ function createLinearTools(options) {
       });
       return { ok: true };
     }
-  );
+  });
   tools.push(
     {
       name: "linear_update_plan",
-      description: "Update the plan for the Linear agent session, showing progress on each step.",
+      description: "Update the structured plan for the Linear agent session. Renders as a native checklist in the Linear Agent Session UI with live status indicators.",
       schema: import_zod.z.object({
         session_id: import_zod.z.string().describe("The Linear agent session ID"),
         steps: import_zod.z.array(import_zod.z.object({
@@ -1575,6 +2071,35 @@ function createLinearTools(options) {
     optionalIssueIdSchema,
     issueCommentLimitSchema
   });
+  if (typeof client.issueRepositorySuggestions === "function") {
+    const suggestRepositories = client.issueRepositorySuggestions.bind(client);
+    tools.push({
+      name: "linear_suggest_repositories",
+      description: "Ask Linear to rank candidate repositories by relevance for the current issue. Returns ranked suggestions with confidence scores. Use this before asking the user which repository to work in \u2014 if a suggestion has high confidence, auto-select it; otherwise present the top options via the select elicitation signal.",
+      schema: requiredIssueIdSchema.extend({
+        session_id: import_zod.z.string().describe("The Linear agent session ID"),
+        repositories: import_zod.z.array(
+          import_zod.z.object({
+            hostname: import_zod.z.string().describe("Hostname of the Git service (e.g. 'github.com')"),
+            repositoryFullName: import_zod.z.string().describe("Full name in owner/name format (e.g. 'acme/backend')")
+          })
+        ).min(1).max(50).describe("Candidate repositories the agent has access to")
+      }),
+      handler: async (args) => {
+        const issueId = resolveIssueId("linear_suggest_repositories", args);
+        const sessionId = args.session_id;
+        const candidates = args.repositories;
+        const response = await suggestRepositories(
+          candidates,
+          issueId,
+          { agentSessionId: sessionId }
+        );
+        const suggestions = extractRepositorySuggestions(response);
+        return { suggestions };
+      }
+    });
+  }
+  addSessionCreationTools({ tools, client, store, logger });
   return tools;
 }
 function addIssueTools(input) {
@@ -1628,6 +2153,7 @@ function addIssueTools(input) {
         priority: import_zod.z.number().int().min(0).max(4).optional().describe("Priority 0-4"),
         state_id: import_zod.z.string().optional().describe("Workflow state ID"),
         assignee_id: import_zod.z.string().nullable().optional().describe("Assignee user ID, or null to unassign"),
+        delegate_id: import_zod.z.string().nullable().optional().describe("Agent user ID to delegate the issue to, or null to clear delegate"),
         estimate: import_zod.z.number().int().optional().describe("Estimate points"),
         due_date: import_zod.z.string().optional().describe("Due date ISO string")
       }),
@@ -1636,7 +2162,7 @@ function addIssueTools(input) {
           throw new Error("linear_update_issue is unavailable: Linear client does not support updateIssue().");
         }
         const issueId = resolveIssueId("linear_update_issue", args);
-        const hasUpdates = args.title !== void 0 || args.description !== void 0 || args.priority !== void 0 || args.state_id !== void 0 || args.assignee_id !== void 0 || args.estimate !== void 0 || args.due_date !== void 0;
+        const hasUpdates = args.title !== void 0 || args.description !== void 0 || args.priority !== void 0 || args.state_id !== void 0 || args.assignee_id !== void 0 || args.delegate_id !== void 0 || args.estimate !== void 0 || args.due_date !== void 0;
         if (!hasUpdates) {
           throw new Error("linear_update_issue requires at least one update field.");
         }
@@ -1648,6 +2174,7 @@ function addIssueTools(input) {
             ...args.priority !== void 0 ? { priority: args.priority } : {},
             ...args.state_id !== void 0 ? { stateId: args.state_id } : {},
             ...args.assignee_id !== void 0 ? { assigneeId: args.assignee_id } : {},
+            ...args.delegate_id !== void 0 ? { delegateId: args.delegate_id } : {},
             ...args.estimate !== void 0 ? { estimate: args.estimate } : {},
             ...args.due_date !== void 0 ? { dueDate: args.due_date } : {}
           }
@@ -1678,7 +2205,7 @@ function addIssueTools(input) {
 function assertUuid(toolName, value) {
   const uuidPattern = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
   if (!uuidPattern.test(value)) {
-    throw new Error(`${toolName} requires the exact Linear issue UUID from the session context. Received "${value}".`);
+    throw new Error(`${toolName} requires the exact Linear UUID from the session context (not the human-readable identifier). Received "${value}".`);
   }
 }
 function resolveIssueId(toolName, args) {
@@ -1721,6 +2248,11 @@ async function readIssue(client, issueId) {
         id: issue.assignee.id ?? null,
         name: issue.assignee.displayName ?? issue.assignee.name ?? null
       } : null,
+      delegate: issue.delegate ? {
+        id: issue.delegate.id ?? null,
+        name: issue.delegate.displayName ?? issue.delegate.name ?? null
+      } : null,
+      delegate_id: issue.delegateId ?? null,
       team: issue.team ? {
         id: issue.team.id ?? null,
         key: issue.team.key ?? null,
@@ -1776,6 +2308,296 @@ async function readWorkflowStates(client, teamId) {
   })).sort((left, right) => (left.position ?? Number.MAX_SAFE_INTEGER) - (right.position ?? Number.MAX_SAFE_INTEGER));
   return { team_id: teamId, states };
 }
+function addSessionCreationTools(input) {
+  const { tools, client, store, logger } = input;
+  const sessionCreationBaseSchema = import_zod.z.object({
+    external_link: import_zod.z.string().url().optional().describe("Optional URL of an external page associated with this session"),
+    room_id: import_zod.z.string().min(1).optional().describe("The Band room ID to persist the session-room mapping. Pass this when creating a session from within a Band conversation.")
+  });
+  const sessionCreationSchema = sessionCreationBaseSchema.extend({
+    issue_id: import_zod.z.string().uuid().describe("The Linear issue ID (UUID)")
+  });
+  async function persistSessionRoom(sessionId, issueId, roomId) {
+    if (!store || typeof roomId !== "string") return null;
+    try {
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      await store.upsert({
+        linearSessionId: sessionId,
+        linearIssueId: issueId,
+        bandRoomId: roomId,
+        status: "active",
+        createdAt: now,
+        updatedAt: now
+      });
+      return null;
+    } catch (err) {
+      logger?.warn("linear_tools.session_room_persist_failed", {
+        sessionId,
+        issueId,
+        roomId,
+        error: err instanceof Error ? err.message : String(err)
+      });
+      return "session-room mapping not persisted";
+    }
+  }
+  const createOnIssue = client.agentSessionCreateOnIssue?.bind(client);
+  if (typeof createOnIssue === "function") {
+    tools.push({
+      name: "linear_create_session_on_issue",
+      description: "Create a new Linear agent session on an existing issue. Use this when the conversation produces work that should be tracked against a known Linear issue and no session exists yet.",
+      schema: sessionCreationSchema,
+      handler: async (args) => {
+        const issueId = args.issue_id;
+        const result = await createOnIssue({
+          issueId,
+          ...typeof args.external_link === "string" ? { externalLink: args.external_link } : {}
+        });
+        const session = extractCreatedSession(result, logger);
+        const warning = await persistSessionRoom(session.id, session.issueId, args.room_id);
+        return { ok: true, session, ...warning ? { warning } : {} };
+      }
+    });
+  }
+  const createOnComment = client.agentSessionCreateOnComment?.bind(client);
+  if (typeof createOnComment === "function") {
+    tools.push({
+      name: "linear_create_session_on_comment",
+      description: "Create a new Linear agent session on a specific comment thread. Use this to attach agent work to an existing discussion on a Linear issue.",
+      schema: sessionCreationBaseSchema.extend({
+        comment_id: import_zod.z.string().uuid().describe("The Linear comment ID (UUID)")
+      }),
+      handler: async (args) => {
+        const commentId = args.comment_id;
+        const result = await createOnComment({
+          commentId,
+          ...typeof args.external_link === "string" ? { externalLink: args.external_link } : {}
+        });
+        const session = extractCreatedSession(result, logger);
+        const warning = await persistSessionRoom(session.id, session.issueId, args.room_id);
+        return { ok: true, session, ...warning ? { warning } : {} };
+      }
+    });
+  }
+  const createIssueFn = client.createIssue?.bind(client);
+  if (typeof createIssueFn === "function") {
+    tools.push({
+      name: "linear_create_issue",
+      description: "Create a new Linear issue from scratch. Use this when the Band conversation produces work that should be tracked as a new Linear issue. After creating the issue, call linear_create_session_on_issue to attach an agent session. Never create issues without explicit human intent or clear delegation.",
+      schema: import_zod.z.object({
+        team_id: import_zod.z.string().uuid().describe("The Linear team ID to create the issue in"),
+        title: import_zod.z.string().min(1).describe("Issue title"),
+        description: import_zod.z.string().optional().describe("Issue description in Markdown"),
+        priority: import_zod.z.number().int().min(0).max(4).optional().describe("Priority 0-4 (0=none, 1=urgent, 2=high, 3=normal, 4=low)"),
+        assignee_id: import_zod.z.string().uuid().optional().describe("Assignee user ID (UUID)"),
+        state_id: import_zod.z.string().uuid().optional().describe("Workflow state ID (UUID)"),
+        label_ids: import_zod.z.array(import_zod.z.string().uuid()).optional().describe("Label IDs to attach (UUIDs)")
+      }),
+      handler: async (args) => {
+        const result = await createIssueFn({
+          teamId: args.team_id,
+          title: args.title,
+          ...typeof args.description === "string" ? { description: args.description } : {},
+          ...typeof args.priority === "number" ? { priority: args.priority } : {},
+          ...typeof args.assignee_id === "string" ? { assigneeId: args.assignee_id } : {},
+          ...typeof args.state_id === "string" ? { stateId: args.state_id } : {},
+          ...Array.isArray(args.label_ids) ? { labelIds: args.label_ids } : {}
+        });
+        const issue = extractCreatedIssue(result, logger);
+        return { ok: true, issue };
+      }
+    });
+  }
+}
+function extractCreatedSession(result, logger) {
+  const payload = typeof result === "object" && result !== null ? result : {};
+  const session = typeof payload.agentSession === "object" && payload.agentSession !== null ? payload.agentSession : payload;
+  const id = typeof session.id === "string" ? session.id : null;
+  if (!id) {
+    logger?.error("linear_tools.orphan_session_created", {
+      raw: safeStringify(result)
+    });
+    throw new Error("Linear API returned a session without an ID.");
+  }
+  return {
+    id,
+    issueId: typeof session.issueId === "string" ? session.issueId : null,
+    status: typeof session.status === "string" ? session.status : null
+  };
+}
+function extractCreatedIssue(result, logger) {
+  const payload = typeof result === "object" && result !== null ? result : {};
+  const issue = typeof payload.issue === "object" && payload.issue !== null ? payload.issue : payload;
+  const id = typeof issue.id === "string" ? issue.id : null;
+  if (!id) {
+    logger?.error("linear_tools.orphan_issue_created", {
+      raw: safeStringify(result)
+    });
+    throw new Error("Linear API returned an issue without an ID.");
+  }
+  return {
+    id,
+    identifier: typeof issue.identifier === "string" ? issue.identifier : null,
+    url: typeof issue.url === "string" ? issue.url : null,
+    title: typeof issue.title === "string" ? issue.title : null
+  };
+}
+function safeStringify(value) {
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return String(value);
+  }
+}
+function extractRepositorySuggestions(response) {
+  if (response == null || typeof response !== "object") {
+    return [];
+  }
+  const payload = response;
+  if (!Array.isArray(payload.suggestions)) {
+    return [];
+  }
+  return payload.suggestions.filter(
+    (entry) => entry != null && typeof entry === "object" && typeof entry.repositoryFullName === "string"
+  ).map((entry) => ({
+    repositoryFullName: entry.repositoryFullName,
+    hostname: typeof entry.hostname === "string" ? entry.hostname : null,
+    confidence: typeof entry.confidence === "number" ? entry.confidence : 0
+  })).sort((a, b) => b.confidence - a.confidence);
+}
+
+// src/integrations/linear/notification.ts
+var MAX_COMMENT_LENGTH = 4e3;
+var MAX_ACTOR_NAME_LENGTH = 100;
+function sanitizeInlineText(text) {
+  return text.replace(/[\x00-\x1f\x7f]/g, " ").trim();
+}
+function sanitizeBodyText(text) {
+  return text.replace(/[\x00-\x08\x0b\x0c\x0e-\x1f\x7f]/g, "").trim();
+}
+async function handleAppUserNotification(input) {
+  const { payload, deps, logger, appUserId } = input;
+  const notification = payload.notification;
+  const typename = notification.__typename;
+  switch (typename) {
+    case "IssueUnassignedFromYouNotificationWebhookPayload":
+      await handleIssueUnassigned({
+        notification,
+        deps,
+        logger
+      });
+      return;
+    case "IssueNewCommentNotificationWebhookPayload":
+      await handleIssueNewComment({
+        notification,
+        deps,
+        logger,
+        appUserId
+      });
+      return;
+    case "IssueCommentReactionNotificationWebhookPayload":
+    case "IssueEmojiReactionNotificationWebhookPayload":
+      logReaction({
+        notification,
+        logger
+      });
+      return;
+    default:
+      logger.info("linear_thenvoi_bridge.notification_unhandled", {
+        notificationType: typename
+      });
+  }
+}
+async function handleIssueUnassigned(input) {
+  const { notification, deps, logger } = input;
+  const existing = await deps.store.getByIssueId(notification.issueId);
+  if (!existing || existing.status !== "active" && existing.status !== "waiting") {
+    logger.info("linear_thenvoi_bridge.notification_unassigned_no_session", {
+      issueId: notification.issueId,
+      reason: existing ? `session_status_${existing.status}` : "no_active_session"
+    });
+    return;
+  }
+  await deps.bandRest.createChatEvent(existing.bandRoomId, {
+    content: "[Linear]: Issue unassigned from agent. Disengage from active work and await reassignment.",
+    messageType: "task",
+    metadata: {
+      linear_notification_type: "issueUnassignedFromYou",
+      linear_issue_id: notification.issueId,
+      linear_actor_id: notification.actorId ?? null,
+      linear_bridge: "band"
+    }
+  });
+  await deps.store.markCanceled(existing.linearSessionId);
+  logger.info("linear_thenvoi_bridge.notification_unassigned_handled", {
+    issueId: notification.issueId,
+    sessionId: existing.linearSessionId,
+    roomId: existing.bandRoomId
+  });
+}
+async function handleIssueNewComment(input) {
+  const { notification, deps, logger, appUserId } = input;
+  if (appUserId && notification.actorId === appUserId) {
+    logger.info("linear_thenvoi_bridge.notification_comment_self_skipped", {
+      issueId: notification.issueId,
+      commentId: notification.commentId,
+      actorId: notification.actorId
+    });
+    return;
+  }
+  const existing = await deps.store.getByIssueId(notification.issueId);
+  if (!existing || existing.status !== "active" && existing.status !== "waiting") {
+    logger.info("linear_thenvoi_bridge.notification_comment_skipped", {
+      issueId: notification.issueId,
+      reason: existing ? `session_status_${existing.status}` : "no_active_session"
+    });
+    return;
+  }
+  let actorName = sanitizeInlineText(notification.actor?.name ?? "");
+  if (actorName.length > MAX_ACTOR_NAME_LENGTH) {
+    actorName = actorName.slice(0, MAX_ACTOR_NAME_LENGTH) + "\u2026";
+  }
+  if (actorName.length === 0) {
+    actorName = "Unknown user";
+  }
+  let commentBody = sanitizeBodyText(notification.comment.body ?? "");
+  if (commentBody.length > MAX_COMMENT_LENGTH) {
+    commentBody = commentBody.slice(0, MAX_COMMENT_LENGTH) + "\u2026";
+  }
+  if (!notification.actor?.name) {
+    logger.info("linear_thenvoi_bridge.notification_comment_actor_fallback", {
+      issueId: notification.issueId,
+      commentId: notification.commentId,
+      actorId: notification.actorId ?? null
+    });
+  }
+  await deps.bandRest.createChatEvent(existing.bandRoomId, {
+    content: `[Linear Comment from ${actorName}]: ${commentBody}`,
+    messageType: "text",
+    metadata: {
+      linear_notification_type: "issueNewComment",
+      linear_issue_id: notification.issueId,
+      linear_comment_id: notification.commentId,
+      linear_actor_id: notification.actorId ?? null,
+      linear_bridge: "band"
+    }
+  });
+  logger.info("linear_thenvoi_bridge.notification_comment_forwarded", {
+    issueId: notification.issueId,
+    commentId: notification.commentId,
+    sessionId: existing.linearSessionId,
+    roomId: existing.bandRoomId
+  });
+}
+function logReaction(input) {
+  const { notification, logger } = input;
+  logger.info("linear_thenvoi_bridge.notification_reaction", {
+    notificationType: notification.__typename,
+    issueId: notification.issueId,
+    actorId: notification.actorId ?? null,
+    commentId: "commentId" in notification ? notification.commentId : null,
+    reactionEmoji: notification.reactionEmoji
+  });
+}
 
 // src/integrations/linear/webhook.ts
 var import_webhooks = require("@linear/sdk/webhooks");
@@ -1911,6 +2733,7 @@ function createLinearWebhookHandler(options) {
   const dispatcher = options.dispatcher ?? createInlineLinearBridgeDispatcher({ logger });
   const webhookClient = new import_webhooks.LinearWebhookClient(options.config.linearWebhookSecret);
   const inFlightEventKeys = /* @__PURE__ */ new Set();
+  const processedNotificationIds = /* @__PURE__ */ new Set();
   return async (request, response) => {
     if (request.method !== "POST") {
       logger.warn("linear_thenvoi_bridge.webhook_invalid_method", {
@@ -1932,9 +2755,9 @@ function createLinearWebhookHandler(options) {
       return;
     }
     const rawBody = await readRawBody(request);
-    let payload;
+    let parsed;
     try {
-      payload = webhookClient.parseData(
+      parsed = webhookClient.parseData(
         rawBody,
         signature,
         timestamp
@@ -1946,13 +2769,111 @@ function createLinearWebhookHandler(options) {
       sendText(response, 400, "Invalid webhook");
       return;
     }
-    if (payload.type !== "AgentSessionEvent") {
+    if (parsed.type === "AppUserNotification") {
+      const notificationPayload = parsed;
+      if (!notificationPayload.notification) {
+        logger.warn("linear_thenvoi_bridge.webhook_notification_missing_payload", {
+          appUserId: notificationPayload.appUserId ?? null,
+          organizationId: notificationPayload.organizationId ?? null
+        });
+        sendText(response, 200, "OK");
+        return;
+      }
+      const notificationId = notificationPayload.notification?.id;
+      const notificationType = notificationPayload.notification.__typename;
+      const isDedupable = notificationType !== "IssueCommentReactionNotificationWebhookPayload" && notificationType !== "IssueEmojiReactionNotificationWebhookPayload";
+      if (isDedupable && notificationId && processedNotificationIds.has(notificationId)) {
+        logger.info("linear_thenvoi_bridge.webhook_notification_duplicate_ignored", {
+          notificationId
+        });
+        sendText(response, 200, "OK");
+        return;
+      }
+      logger.info("linear_thenvoi_bridge.webhook_notification_received", {
+        notificationType: notificationType ?? null,
+        notificationId: notificationId ?? null,
+        appUserId: notificationPayload.appUserId,
+        organizationId: notificationPayload.organizationId
+      });
+      try {
+        await handleAppUserNotification({
+          payload: notificationPayload,
+          deps: options.deps,
+          logger,
+          appUserId: notificationPayload.appUserId
+        });
+        if (isDedupable && notificationId) {
+          processedNotificationIds.add(notificationId);
+          if (processedNotificationIds.size > 1e3) {
+            const oldest = processedNotificationIds.values().next().value;
+            if (oldest) processedNotificationIds.delete(oldest);
+          }
+        }
+      } catch (error) {
+        logger.error("linear_thenvoi_bridge.webhook_notification_failed", {
+          notificationType: notificationType ?? null,
+          error: serializeError(error)
+        });
+      }
+      sendText(response, 200, "OK");
+      return;
+    }
+    if (parsed.type === "PermissionChange") {
+      const action = parsed.action;
+      if (normalizeAction2(action) === "teamaccesschanged") {
+        const permPayload = parsed;
+        logger.info("linear_thenvoi_bridge.team_access_changed", {
+          action: permPayload.action,
+          addedTeamIds: permPayload.addedTeamIds,
+          removedTeamIds: permPayload.removedTeamIds,
+          canAccessAllPublicTeams: permPayload.canAccessAllPublicTeams,
+          organizationId: permPayload.organizationId
+        });
+        try {
+          await options.permissionCallbacks?.onTeamAccessChanged?.(permPayload);
+        } catch (error) {
+          logger.error("linear_thenvoi_bridge.team_access_changed_callback_failed", {
+            error: serializeError(error)
+          });
+        }
+      } else {
+        logger.info("linear_thenvoi_bridge.permission_change_event_ignored", {
+          action
+        });
+      }
+      sendText(response, 200, "OK");
+      return;
+    }
+    if (parsed.type === "OAuthApp") {
+      const oauthPayload = parsed;
+      if (normalizeAction2(oauthPayload.action) === "revoked") {
+        logger.warn("linear_thenvoi_bridge.oauth_app_revoked", {
+          oauthClientId: oauthPayload.oauthClientId,
+          organizationId: oauthPayload.organizationId
+        });
+        try {
+          await options.permissionCallbacks?.onOAuthAppRevoked?.(oauthPayload);
+        } catch (error) {
+          logger.error("linear_thenvoi_bridge.oauth_app_revoked_callback_failed", {
+            error: serializeError(error)
+          });
+        }
+      } else {
+        logger.info("linear_thenvoi_bridge.oauth_app_event_ignored", {
+          action: oauthPayload.action
+        });
+      }
+      sendText(response, 200, "OK");
+      return;
+    }
+    if (parsed.type !== "AgentSessionEvent") {
       logger.info("linear_thenvoi_bridge.webhook_ignored_event", {
-        type: payload.type
+        type: parsed.type
       });
       sendText(response, 200, "OK");
       return;
     }
+    const payload = parsed;
     const eventKey = getAgentSessionEventKey(payload);
     logger.info("linear_thenvoi_bridge.webhook_received", {
       sessionId: payload.agentSession.id,
@@ -2185,6 +3106,12 @@ var DEFAULT_STATUS_MAPPING = {
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   DEFAULT_STATUS_MAPPING,
+  ELICITATION_BODY_MAX_LENGTH,
+  PROVIDER_MAX_LENGTH,
+  SELECT_OPTION_MAX_LENGTH,
+  STALE_SESSION_CHECK_INTERVAL_MS,
+  STALE_SESSION_THRESHOLD_MS,
+  StaleSessionGuard,
   buildLinearAuthorizationHeader,
   completeLinearSession,
   createInProcessLinearBridgeDispatcher,
@@ -2196,12 +3123,17 @@ var DEFAULT_STATUS_MAPPING = {
   createSqliteSessionRoomStore,
   dedupeHandles,
   handleAgentSessionEvent,
+  handleAppUserNotification,
   isLinearApiKey,
+  isSessionStale,
   postAction,
+  postAuthElicitation,
   postElicitation,
   postError,
   postResponse,
+  postSelectElicitation,
   postThought,
+  sendRecoveryActivityIfStale,
   stripHandlePrefix,
   updatePlan
 });