@band-ai/sdk 0.1.2

package/dist/linear.cjs

@@ -0,0 +1,2207 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/linear/index.ts
+var linear_exports = {};
+__export(linear_exports, {
+  DEFAULT_STATUS_MAPPING: () => DEFAULT_STATUS_MAPPING,
+  buildLinearAuthorizationHeader: () => buildLinearAuthorizationHeader,
+  completeLinearSession: () => completeLinearSession,
+  createInProcessLinearBridgeDispatcher: () => createInProcessLinearBridgeDispatcher,
+  createInlineLinearBridgeDispatcher: () => createInlineLinearBridgeDispatcher,
+  createLinearBridgeRuntime: () => createLinearBridgeRuntime,
+  createLinearClient: () => createLinearClient,
+  createLinearTools: () => createLinearTools,
+  createLinearWebhookHandler: () => createLinearWebhookHandler,
+  createSqliteSessionRoomStore: () => createSqliteSessionRoomStore,
+  dedupeHandles: () => dedupeHandles,
+  handleAgentSessionEvent: () => handleAgentSessionEvent,
+  isLinearApiKey: () => isLinearApiKey,
+  postAction: () => postAction,
+  postElicitation: () => postElicitation,
+  postError: () => postError,
+  postResponse: () => postResponse,
+  postThought: () => postThought,
+  stripHandlePrefix: () => stripHandlePrefix,
+  updatePlan: () => updatePlan
+});
+module.exports = __toCommonJS(linear_exports);
+
+// src/integrations/linear/bridge/handler.ts
+var import_sdk2 = require("@linear/sdk");
+
+// src/core/errors.ts
+var ThenvoiSdkError = class extends Error {
+  constructor(message, cause) {
+    super(message, cause !== void 0 ? { cause } : void 0);
+    this.name = "ThenvoiSdkError";
+  }
+};
+var UnsupportedFeatureError = class extends ThenvoiSdkError {
+  constructor(message) {
+    super(message);
+    this.name = "UnsupportedFeatureError";
+  }
+};
+
+// src/core/logger.ts
+var noop = () => void 0;
+var NoopLogger = class {
+  debug = noop;
+  info = noop;
+  warn = noop;
+  error = noop;
+};
+
+// src/integrations/linear/handles.ts
+function stripHandlePrefix(handle) {
+  return handle.trim().replace(/^@+/, "").toLowerCase();
+}
+function dedupeHandles(handles) {
+  const deduped = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const handle of handles) {
+    const normalized = stripHandlePrefix(handle);
+    if (!normalized || seen.has(normalized)) {
+      continue;
+    }
+    seen.add(normalized);
+    deduped.push(normalized);
+  }
+  return deduped;
+}
+
+// src/integrations/linear/activities.ts
+var import_sdk = require("@linear/sdk");
+async function postActivity(client, sessionId, content) {
+  await client.createAgentActivity({
+    agentSessionId: sessionId,
+    content
+  });
+}
+async function postBodyActivity(client, sessionId, type, body) {
+  await postActivity(client, sessionId, { type, body });
+}
+async function postThought(client, sessionId, body) {
+  await postBodyActivity(client, sessionId, import_sdk.LinearDocument.AgentActivityType.Thought, body);
+}
+async function postError(client, sessionId, body) {
+  await postBodyActivity(client, sessionId, import_sdk.LinearDocument.AgentActivityType.Error, body);
+}
+async function postResponse(client, sessionId, body) {
+  await postBodyActivity(client, sessionId, import_sdk.LinearDocument.AgentActivityType.Response, body);
+}
+async function postElicitation(client, sessionId, body) {
+  await postBodyActivity(client, sessionId, import_sdk.LinearDocument.AgentActivityType.Elicitation, body);
+}
+async function postAction(client, sessionId, body) {
+  await postActivity(client, sessionId, {
+    type: import_sdk.LinearDocument.AgentActivityType.Action,
+    action: body,
+    parameter: ""
+  });
+}
+async function updatePlan(client, sessionId, steps) {
+  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}`;
+  }).join("\n");
+  await postActivity(client, sessionId, {
+    type: import_sdk.LinearDocument.AgentActivityType.Thought,
+    body: `**Plan:**
+${planSummary}`
+  });
+}
+
+// src/integrations/linear/bridge/message.ts
+function buildBridgeMessage(input) {
+  const header = input.action === "created" ? "[Linear]: Agent session created." : "[Linear]: Agent session updated.";
+  const userRequest = firstNonEmpty(
+    input.commentBody,
+    input.promptContext,
+    input.issueTitle ? `Please handle ${input.issueTitle}.` : null
+  ) ?? "Please handle this Linear request.";
+  const issueIdLine = input.issueId ? `issue_id: ${input.issueId}` : "issue_id: none";
+  const issueIdentifierLine = input.issueIdentifier ? `issue_identifier: ${input.issueIdentifier}` : "issue_identifier: none";
+  const issueTitleLine = input.issueTitle ? `issue_title: ${input.issueTitle}` : "issue_title: none";
+  const issueUrlLine = input.issueUrl ? `issue_url: ${input.issueUrl}` : "issue_url: none";
+  const issueTeamLine = firstNonEmpty(input.issueTeamKey, input.issueTeamName) ? `issue_team: ${firstNonEmpty(input.issueTeamKey, input.issueTeamName)}` : "issue_team: none";
+  const issueTeamIdLine = input.issueTeamId ? `issue_team_id: ${input.issueTeamId}` : "issue_team_id: none";
+  const issueStateLine = firstNonEmpty(input.issueStateName, input.issueStateType) ? `issue_state: ${firstNonEmpty(input.issueStateName, input.issueStateType)}` : "issue_state: none";
+  const issueStateIdLine = input.issueStateId ? `issue_state_id: ${input.issueStateId}` : "issue_state_id: none";
+  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 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";
+  const sessionUpdatedLine = input.sessionUpdatedAt ? `session_updated_at: ${input.sessionUpdatedAt}` : "session_updated_at: none";
+  const appUserLine = input.appUserId ? `app_user_id: ${input.appUserId}` : "app_user_id: none";
+  const organizationLine = input.organizationId ? `organization_id: ${input.organizationId}` : "organization_id: none";
+  const oauthClientLine = input.oauthClientId ? `oauth_client_id: ${input.oauthClientId}` : "oauth_client_id: none";
+  const webhookIdLine = input.webhookId ? `webhook_id: ${input.webhookId}` : "webhook_id: none";
+  const webhookTimestampLine = typeof input.webhookTimestamp === "number" ? `webhook_timestamp: ${input.webhookTimestamp}` : "webhook_timestamp: none";
+  const commentIdLine = input.commentId ? `comment_id: ${input.commentId}` : "comment_id: none";
+  const promptContext = firstNonEmpty(input.promptContext) ?? "none";
+  const issueDescription = firstNonEmpty(input.issueDescription) ?? "none";
+  const commentBody = firstNonEmpty(input.commentBody) ?? "none";
+  const suggestedPeersLine = input.suggestedPeerHandles.length > 0 ? input.suggestedPeerHandles.map((handle) => `  - ${handle}`).join("\n") : "  - none";
+  return `${userRequest}
+
+${header}
+
+Linear session context:
+- session_id: ${input.sessionId}
+- ${sessionStatusLine}
+- ${sessionTypeLine}
+- ${sessionCreatedLine}
+- ${sessionUpdatedLine}
+- ${issueIdLine}
+- ${issueIdentifierLine}
+- ${issueTitleLine}
+- ${issueUrlLine}
+- ${issueTeamLine}
+- ${issueTeamIdLine}
+- ${issueStateLine}
+- ${issueStateIdLine}
+- ${issueStateTypeLine}
+- ${issueAssigneeLine}
+- ${issueAssigneeIdLine}
+- inferred_session_intent: ${input.sessionIntent}
+- writeback_mode: ${input.writebackMode}
+- ${appUserLine}
+- ${organizationLine}
+- ${oauthClientLine}
+- ${webhookIdLine}
+- ${webhookTimestampLine}
+
+Bridge responsibilities:
+- own orchestration for this Linear session
+- decide whether you can answer alone or need help
+- discover and invite specialists only when needed
+- 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
+
+Suggested peers available in the registry right now. They are not in the room yet:
+${suggestedPeersLine}
+
+Prompt context:
+${promptContext}
+
+Issue description:
+${issueDescription}
+
+Linked comment:
+- ${commentIdLine}
+${commentBody}`;
+}
+function extractPromptedResponseBody(payload) {
+  if (typeof payload !== "object" || payload === null) {
+    return "";
+  }
+  const record = payload;
+  const activity = record.agentActivity;
+  if (typeof activity !== "object" || activity === null) {
+    return "";
+  }
+  const content = activity.content;
+  if (typeof content !== "object" || content === null) {
+    return "";
+  }
+  const body = content.body;
+  return typeof body === "string" ? body : "";
+}
+function detectSessionIntent(input) {
+  if (input.issueStateType?.trim().toLowerCase() === "started") {
+    return "implementation";
+  }
+  const explicitDirective = [
+    input.promptContext,
+    input.commentBody
+  ].filter((value) => typeof value === "string" && value.trim().length > 0).join(" ").toLowerCase();
+  if (/(please implement|implement (?:this|it|now|the)|build (?:this|it|now|the)|code (?:this|it|now|the)|ship (?:it|this)|start coding|start implementation|tighten|adjust|refine)/.test(explicitDirective)) {
+    return "implementation";
+  }
+  return "planning";
+}
+function extractIssueTeamKey(issue) {
+  const team = extractNestedRecord(issue, "team");
+  return typeof team?.key === "string" ? team.key : null;
+}
+function extractIssueTeamName(issue) {
+  const team = extractNestedRecord(issue, "team");
+  return typeof team?.name === "string" ? team.name : null;
+}
+function extractIssueTeamId(issue) {
+  const issueRecord = extractRecord(issue);
+  if (typeof issueRecord?.teamId === "string") {
+    return issueRecord.teamId;
+  }
+  const team = extractNestedRecord(issue, "team");
+  return typeof team?.id === "string" ? team.id : null;
+}
+function extractIssueStateField(issue, field) {
+  const state = extractNestedRecord(issue, "state");
+  const value = state?.[field];
+  return typeof value === "string" ? value : null;
+}
+function extractIssueAssigneeField(issue, field) {
+  const assignee = extractNestedRecord(issue, "assignee");
+  const value = assignee?.[field];
+  return typeof value === "string" ? value : null;
+}
+function firstNonEmpty(...values) {
+  for (const value of values) {
+    if (!value) {
+      continue;
+    }
+    const trimmed = value.trim();
+    if (trimmed.length > 0) {
+      return trimmed;
+    }
+  }
+  return null;
+}
+function extractNestedRecord(value, key) {
+  const record = extractRecord(value);
+  const nested = record?.[key];
+  return extractRecord(nested);
+}
+function extractRecord(value) {
+  return typeof value === "object" && value !== null ? value : null;
+}
+
+// src/integrations/linear/bridge/handler.ts
+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;
+function createLinearBridgeRuntime() {
+  return {
+    roomResolutionLocks: /* @__PURE__ */ new Map(),
+    resolvedHostHandleCache: /* @__PURE__ */ new WeakMap(),
+    authenticatedHostHandleCache: /* @__PURE__ */ new WeakMap()
+  };
+}
+function getAgentSessionEventKey(payload) {
+  return [
+    payload.agentSession.id,
+    normalizeAction(payload.action) ?? String(payload.action ?? "unknown"),
+    payload.agentSession.updatedAt ?? payload.agentSession.createdAt ?? "",
+    typeof payload.webhookTimestamp === "number" ? String(payload.webhookTimestamp) : ""
+  ].join(":");
+}
+async function handleAgentSessionEvent(input, options) {
+  const logger = input.deps.logger ?? new NoopLogger();
+  const config = normalizeConfig(input.config);
+  const action = normalizeAction(input.payload.action);
+  const runtime = options?.runtime ?? createLinearBridgeRuntime();
+  if (!action) {
+    logger.warn("linear_thenvoi_bridge.ignored_unknown_action", {
+      action: input.payload.action,
+      sessionId: input.payload.agentSession.id
+    });
+    return;
+  }
+  const sessionId = input.payload.agentSession.id;
+  const issueId = input.payload.agentSession.issueId ?? input.payload.agentSession.issue?.id ?? null;
+  const eventKey = options?.expectedEventKey ?? getAgentSessionEventKey(input.payload);
+  const existingBySession = await input.deps.store.getBySessionId(sessionId);
+  if (existingBySession?.lastEventKey === eventKey) {
+    logger.info("linear_thenvoi_bridge.duplicate_event_skipped", {
+      sessionId,
+      issueId,
+      action,
+      eventKey
+    });
+    return;
+  }
+  if (action === "canceled") {
+    await handleCanceledAction({
+      deps: input.deps,
+      logger,
+      sessionId,
+      issueId,
+      eventKey,
+      payloadAction: input.payload.action,
+      skipRoomWrite: options?.skipRoomWrite ?? false
+    });
+    return;
+  }
+  if (action === "prompted") {
+    await handlePromptedAction({
+      deps: input.deps,
+      config,
+      logger,
+      sessionId,
+      eventKey,
+      payload: input.payload,
+      skipRoomWrite: options?.skipRoomWrite ?? false
+    });
+    return;
+  }
+  if (action === "created" && !options?.skipAcknowledgment) {
+    try {
+      await postThought(input.deps.linearClient, sessionId, "Received session. Setting up workspace...");
+    } catch (ackError) {
+      logger.warn("linear_thenvoi_bridge.acknowledgment_failed", {
+        sessionId,
+        error: ackError instanceof Error ? ackError.message : String(ackError)
+      });
+    }
+  }
+  let roomRecord = null;
+  try {
+    const hostAgentHandle = await resolveHostAgentHandle({
+      thenvoiRest: input.deps.thenvoiRest,
+      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,
+      store: input.deps.store,
+      roomStrategy: config.roomStrategy,
+      sessionId,
+      issueId,
+      logger,
+      runtime
+    });
+    const sessionIntent = detectSessionIntent({
+      issueStateType: extractIssueStateField(input.payload.agentSession.issue, "type"),
+      promptContext: input.payload.promptContext,
+      commentBody: input.payload.agentSession.comment?.body,
+      issueTitle: input.payload.agentSession.issue?.title,
+      issueDescription: input.payload.agentSession.issue?.description
+    });
+    const suggestedPeerHandles = await selectRelevantPeerHandles({
+      thenvoiRest: input.deps.thenvoiRest,
+      roomId: roomRecord.thenvoiRoomId,
+      intent: sessionIntent,
+      hostAgentHandle,
+      planningAgentHandles: input.config.planningAgentHandles,
+      implementationAgentHandles: input.config.implementationAgentHandles,
+      logger
+    });
+    await ensureRoomParticipants({
+      thenvoiRest: input.deps.thenvoiRest,
+      roomId: roomRecord.thenvoiRoomId,
+      handles: [hostAgentHandle],
+      logger
+    });
+    const message = buildBridgeMessage({
+      sessionId,
+      issueId,
+      issueIdentifier: input.payload.agentSession.issue?.identifier,
+      sessionStatus: input.payload.agentSession.status,
+      sessionType: input.payload.agentSession.type,
+      sessionCreatedAt: input.payload.agentSession.createdAt,
+      sessionUpdatedAt: input.payload.agentSession.updatedAt,
+      action,
+      hostHandle: hostAgentHandle,
+      promptContext: input.payload.promptContext,
+      issueTitle: input.payload.agentSession.issue?.title,
+      issueDescription: input.payload.agentSession.issue?.description,
+      issueUrl: input.payload.agentSession.issue?.url,
+      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"),
+      issueAssigneeId: extractIssueAssigneeField(input.payload.agentSession.issue, "id"),
+      issueAssigneeName: extractIssueAssigneeField(input.payload.agentSession.issue, "displayName") ?? extractIssueAssigneeField(input.payload.agentSession.issue, "name"),
+      commentBody: input.payload.agentSession.comment?.body,
+      commentId: input.payload.agentSession.comment?.id,
+      sessionIntent,
+      suggestedPeerHandles,
+      webhookId: input.payload.webhookId,
+      webhookTimestamp: input.payload.webhookTimestamp,
+      oauthClientId: input.payload.oauthClientId,
+      organizationId: input.payload.organizationId,
+      appUserId: input.payload.appUserId,
+      writebackMode: config.writebackMode
+    });
+    const messageMetadata = {
+      linear_event_action: action,
+      linear_session_id: sessionId,
+      linear_issue_id: issueId,
+      linear_prompt_context: input.payload.promptContext ?? null,
+      linear_writeback_mode: config.writebackMode,
+      linear_bridge: "thenvoi",
+      linear_host_handle: hostAgentHandle
+    };
+    const shouldResetRoomSession = Boolean(
+      existingByIssue && existingByIssue.linearSessionId !== sessionId && existingByIssue.thenvoiRoomId === roomRecord.thenvoiRoomId && (existingByIssue.status === "completed" || existingByIssue.status === "errored")
+    );
+    const authenticatedHostHandle = runtime.authenticatedHostHandleCache.get(input.deps.thenvoiRest) ?? null;
+    const canBootstrapDirectly = options?.skipRoomWrite === true || authenticatedHostHandle === null || authenticatedHostHandle === hostAgentHandle;
+    if (!options?.skipRoomWrite || !canBootstrapDirectly) {
+      roomRecord = await forwardBridgeMessage({
+        thenvoiRest: input.deps.thenvoiRest,
+        store: input.deps.store,
+        logger,
+        roomRecord,
+        hostAgentHandle,
+        sessionId,
+        issueId,
+        message,
+        messageType: "task",
+        metadata: messageMetadata,
+        recoveredRoomRetryBaseDelayMs: input.config.recoveredRoomRetryBaseDelayMs
+      });
+    }
+    if (canBootstrapDirectly) {
+      const linearActor = resolveLinearActor(input.payload);
+      await enqueueBootstrapRequest(input.deps.store, {
+        eventKey,
+        linearSessionId: sessionId,
+        thenvoiRoomId: roomRecord.thenvoiRoomId,
+        expectedContent: message,
+        messageType: "task",
+        senderId: linearActor.id,
+        senderName: linearActor.name,
+        metadata: shouldResetRoomSession ? {
+          ...messageMetadata,
+          linear_reset_room_session: true
+        } : messageMetadata
+      });
+    }
+    await saveSessionRecord(input.deps.store, {
+      ...roomRecord,
+      status: "active",
+      lastEventKey: eventKey,
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    logger.info("linear_thenvoi_bridge.message_forwarded", {
+      sessionId,
+      issueId,
+      roomId: roomRecord.thenvoiRoomId,
+      action
+    });
+  } catch (error) {
+    try {
+      await postError(
+        input.deps.linearClient,
+        sessionId,
+        `Bridge error: ${error instanceof Error ? error.message : String(error)}`
+      );
+    } catch (reportError) {
+      logger.warn("linear_thenvoi_bridge.error_reporting_failed", {
+        sessionId,
+        error: reportError instanceof Error ? reportError.message : String(reportError)
+      });
+    }
+    if (roomRecord) {
+      await saveSessionRecord(input.deps.store, {
+        ...roomRecord,
+        status: "errored",
+        lastEventKey: eventKey,
+        updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+      });
+    } else if (existingBySession) {
+      await saveSessionRecord(input.deps.store, {
+        ...existingBySession,
+        status: "errored",
+        lastEventKey: eventKey,
+        updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+      });
+    }
+    throw error;
+  }
+}
+async function completeLinearSession(input) {
+  await input.linearClient.createAgentActivity({
+    agentSessionId: input.agentSessionId,
+    content: {
+      type: import_sdk2.LinearDocument.AgentActivityType.Response,
+      body: input.body
+    }
+  });
+  if (!input.store) {
+    return;
+  }
+  const existing = await input.store.getBySessionId(input.agentSessionId);
+  if (!existing) {
+    return;
+  }
+  await saveSessionRecord(input.store, {
+    ...existing,
+    status: "completed",
+    lastEventKey: input.lastEventKey ?? existing.lastEventKey ?? null,
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  });
+}
+function normalizeConfig(config) {
+  return {
+    roomStrategy: config.roomStrategy ?? "issue",
+    writebackMode: config.writebackMode ?? "final_only",
+    hostAgentHandle: normalizeOptionalHandle(config.hostAgentHandle)
+  };
+}
+function normalizeOptionalHandle(handle) {
+  if (!handle) {
+    return null;
+  }
+  const normalized = stripHandlePrefix(handle);
+  return normalized.length > 0 ? normalized : null;
+}
+async function resolveHostAgentHandle(input) {
+  if (input.configuredHostHandle) {
+    input.runtime.resolvedHostHandleCache.set(input.thenvoiRest, input.configuredHostHandle);
+    return input.configuredHostHandle;
+  }
+  const cachedAuthenticated = input.runtime.authenticatedHostHandleCache.get(input.thenvoiRest);
+  if (cachedAuthenticated) {
+    input.runtime.resolvedHostHandleCache.set(input.thenvoiRest, cachedAuthenticated);
+    return cachedAuthenticated;
+  }
+  const cached = input.runtime.resolvedHostHandleCache.get(input.thenvoiRest);
+  if (cached) {
+    return cached;
+  }
+  const identity = await input.thenvoiRest.getAgentMe();
+  const authenticatedAgentHandle = normalizeOptionalHandle(identity.handle);
+  if (authenticatedAgentHandle) {
+    input.runtime.authenticatedHostHandleCache.set(input.thenvoiRest, authenticatedAgentHandle);
+    input.runtime.resolvedHostHandleCache.set(input.thenvoiRest, authenticatedAgentHandle);
+    return authenticatedAgentHandle;
+  }
+  throw new Error(
+    "Linear bridge could not resolve the host agent handle. Set hostAgentHandle or use a REST adapter whose getAgentMe() returns handle."
+  );
+}
+function normalizeAction(action) {
+  if (!action) {
+    return null;
+  }
+  const normalized = action.trim().toLowerCase();
+  if (!SUPPORTED_ACTIONS.has(normalized)) {
+    return null;
+  }
+  return normalized;
+}
+async function handleCanceledAction(input) {
+  const existing = await input.deps.store.getBySessionId(input.sessionId);
+  if (!existing) {
+    input.logger.info("linear_thenvoi_bridge.session_canceled_without_room", {
+      sessionId: input.sessionId,
+      issueId: input.issueId,
+      action: input.payloadAction
+    });
+    return;
+  }
+  await saveSessionRecord(input.deps.store, {
+    ...existing,
+    status: "canceled",
+    lastEventKey: input.eventKey,
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  });
+  if (!input.skipRoomWrite) {
+    await input.deps.thenvoiRest.createChatEvent(existing.thenvoiRoomId, {
+      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"
+      }
+    });
+  }
+  input.logger.info("linear_thenvoi_bridge.session_canceled", {
+    sessionId: input.sessionId,
+    issueId: input.issueId,
+    hadRoom: Boolean(existing),
+    action: input.payloadAction
+  });
+}
+async function handlePromptedAction(input) {
+  const existing = await input.deps.store.getBySessionId(input.sessionId);
+  if (!existing) {
+    input.logger.warn("linear_thenvoi_bridge.prompted_no_room", {
+      sessionId: input.sessionId
+    });
+    return;
+  }
+  const userResponse = extractPromptedResponseBody(input.payload);
+  if (!userResponse) {
+    input.logger.warn("linear_thenvoi_bridge.prompted_empty_response", {
+      sessionId: input.sessionId
+    });
+    return;
+  }
+  const message = `[Linear User Response]: ${userResponse}`;
+  const metadata = {
+    linear_event_action: "prompted",
+    linear_session_id: input.sessionId,
+    linear_bridge: "thenvoi"
+  };
+  const canBootstrapDirectly = input.config.hostAgentHandle !== null ? true : Boolean(normalizeOptionalHandle((await input.deps.thenvoiRest.getAgentMe()).handle));
+  if (!input.skipRoomWrite || !canBootstrapDirectly) {
+    await input.deps.thenvoiRest.createChatEvent(existing.thenvoiRoomId, {
+      content: message,
+      messageType: "text",
+      metadata
+    });
+  }
+  if (canBootstrapDirectly) {
+    const linearActor = resolveLinearActor(input.payload);
+    await enqueueBootstrapRequest(input.deps.store, {
+      eventKey: input.eventKey,
+      linearSessionId: input.sessionId,
+      thenvoiRoomId: existing.thenvoiRoomId,
+      expectedContent: message,
+      messageType: "text",
+      senderId: linearActor.id,
+      senderName: linearActor.name,
+      metadata
+    });
+  }
+  await saveSessionRecord(input.deps.store, {
+    ...existing,
+    status: "waiting",
+    lastEventKey: input.eventKey,
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  });
+  input.logger.info("linear_thenvoi_bridge.prompted_forwarded", {
+    sessionId: input.sessionId,
+    roomId: existing.thenvoiRoomId
+  });
+}
+async function enqueueBootstrapRequest(store, request) {
+  const now = /* @__PURE__ */ new Date();
+  await store.enqueueBootstrapRequest({
+    ...request,
+    createdAt: now.toISOString(),
+    expiresAt: new Date(now.getTime() + 10 * 6e4).toISOString()
+  });
+}
+function resolveLinearActor(payload) {
+  const creator = payload.agentSession.creator;
+  const creatorName = typeof creator?.name === "string" ? creator.name.trim() : "";
+  const creatorId = typeof creator?.id === "string" ? creator.id.trim() : "";
+  if (creatorName.length > 0) {
+    return {
+      id: creatorId.length > 0 ? creatorId : payload.agentSession.creatorId ?? payload.appUserId ?? null,
+      name: creatorName
+    };
+  }
+  return {
+    id: payload.agentSession.creatorId ?? payload.appUserId ?? null,
+    name: "Linear User"
+  };
+}
+async function resolveRoomRecord(input) {
+  const lockScope = input.roomStrategy === "issue" && input.issueId ? `issue:${input.issueId}` : `session:${input.sessionId}`;
+  const existing = input.runtime.roomResolutionLocks.get(lockScope);
+  if (existing) {
+    return existing;
+  }
+  const promise = resolveRoomRecordImpl(input);
+  input.runtime.roomResolutionLocks.set(lockScope, promise);
+  try {
+    return await promise;
+  } finally {
+    input.runtime.roomResolutionLocks.delete(lockScope);
+  }
+}
+async function forwardBridgeMessage(input) {
+  try {
+    await input.thenvoiRest.createChatEvent(input.roomRecord.thenvoiRoomId, {
+      content: input.message,
+      messageType: input.messageType,
+      metadata: input.metadata
+    });
+    return input.roomRecord;
+  } catch (error) {
+    if (!isRecoverableRoomAccessError(error)) {
+      throw error;
+    }
+    input.logger.warn("linear_thenvoi_bridge.room_forward_recovering_with_fresh_room", {
+      sessionId: input.sessionId,
+      issueId: input.issueId,
+      previousRoomId: input.roomRecord.thenvoiRoomId,
+      error: error instanceof Error ? error.message : String(error)
+    });
+    const recoveredRoom = await createFreshRoomRecord({
+      thenvoiRest: input.thenvoiRest,
+      store: input.store,
+      sessionId: input.sessionId,
+      issueId: input.issueId,
+      logger: input.logger
+    });
+    await ensureRoomParticipants({
+      thenvoiRest: input.thenvoiRest,
+      roomId: recoveredRoom.thenvoiRoomId,
+      handles: [input.hostAgentHandle],
+      logger: input.logger
+    });
+    let attempt = 0;
+    while (true) {
+      try {
+        await input.thenvoiRest.createChatEvent(recoveredRoom.thenvoiRoomId, {
+          content: input.message,
+          messageType: input.messageType,
+          metadata: input.metadata
+        });
+        return recoveredRoom;
+      } catch (recoveredError) {
+        if (!isRetryableRecoveredRoomEventError(recoveredError) || attempt >= RECOVERED_ROOM_EVENT_RETRY_LIMIT) {
+          throw recoveredError;
+        }
+        attempt += 1;
+        const retryBaseDelayMs = input.recoveredRoomRetryBaseDelayMs ?? RECOVERED_ROOM_EVENT_RETRY_BASE_DELAY_MS;
+        const delayMs = retryBaseDelayMs * attempt;
+        input.logger.warn("linear_thenvoi_bridge.room_recreated_retrying", {
+          sessionId: input.sessionId,
+          issueId: input.issueId,
+          roomId: recoveredRoom.thenvoiRoomId,
+          attempt,
+          delayMs,
+          error: recoveredError instanceof Error ? recoveredError.message : String(recoveredError)
+        });
+        await sleep(delayMs);
+      }
+    }
+  }
+}
+function isRecoverableRoomAccessError(error) {
+  if (!(error instanceof Error)) {
+    return false;
+  }
+  return /\/api\/v1\/agent\/chats\/.+\/events failed \((403|404)/.test(error.message);
+}
+function isRetryableRecoveredRoomEventError(error) {
+  if (!(error instanceof Error)) {
+    return false;
+  }
+  return /\/api\/v1\/agent\/chats\/.+\/events failed \((403|404|429)/.test(error.message);
+}
+function isRetryableRateLimitError(error) {
+  if (typeof error === "object" && error !== null && "retryable" in error) {
+    return error.retryable === true;
+  }
+  return error instanceof Error && /\b429\b/.test(error.message);
+}
+async function createFreshRoomRecord(input) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const created = await input.thenvoiRest.createChat();
+  const record = {
+    linearSessionId: input.sessionId,
+    linearIssueId: input.issueId,
+    thenvoiRoomId: created.id,
+    status: "active",
+    lastEventKey: null,
+    createdAt: now,
+    updatedAt: now
+  };
+  await input.store.upsert(record);
+  input.logger.info("linear_thenvoi_bridge.room_recreated", {
+    sessionId: input.sessionId,
+    issueId: input.issueId,
+    roomId: created.id
+  });
+  return record;
+}
+async function resolveRoomRecordImpl(input) {
+  const existingBySession = await input.store.getBySessionId(input.sessionId);
+  if (existingBySession && existingBySession.status !== "canceled") {
+    return existingBySession;
+  }
+  if (input.roomStrategy === "issue" && input.issueId) {
+    const existingByIssue = await input.store.getByIssueId(input.issueId);
+    if (existingByIssue && existingByIssue.status !== "canceled") {
+      const now2 = (/* @__PURE__ */ new Date()).toISOString();
+      const linkedRecord = {
+        linearSessionId: input.sessionId,
+        linearIssueId: input.issueId,
+        thenvoiRoomId: existingByIssue.thenvoiRoomId,
+        status: "active",
+        lastEventKey: existingBySession?.lastEventKey ?? null,
+        createdAt: existingBySession?.createdAt ?? now2,
+        updatedAt: now2
+      };
+      await input.store.upsert(linkedRecord);
+      return linkedRecord;
+    }
+  }
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const created = await input.thenvoiRest.createChat();
+  const createdRecord = {
+    linearSessionId: input.sessionId,
+    linearIssueId: input.issueId,
+    thenvoiRoomId: created.id,
+    status: "active",
+    lastEventKey: null,
+    createdAt: now,
+    updatedAt: now
+  };
+  await input.store.upsert(createdRecord);
+  input.logger.info("linear_thenvoi_bridge.room_created", {
+    sessionId: input.sessionId,
+    issueId: input.issueId,
+    roomId: created.id,
+    roomStrategy: input.roomStrategy
+  });
+  return createdRecord;
+}
+async function ensureRoomParticipants(input) {
+  if (input.handles.length === 0) {
+    return;
+  }
+  let existingParticipants;
+  try {
+    existingParticipants = await input.thenvoiRest.listChatParticipants(input.roomId);
+  } catch (error) {
+    if (isRetryableRateLimitError(error)) {
+      input.logger.warn("linear_thenvoi_bridge.participant_list_rate_limited", {
+        roomId: input.roomId,
+        error: error instanceof Error ? error.message : String(error)
+      });
+      return;
+    }
+    throw error;
+  }
+  const existingHandles = new Set(
+    existingParticipants.map((participant) => stripHandlePrefix(participant.handle ?? participant.name)).filter((value) => value.length > 0)
+  );
+  const missingHandles = input.handles.filter((handle) => !existingHandles.has(handle));
+  if (missingHandles.length === 0) {
+    return;
+  }
+  let peersByHandle;
+  try {
+    peersByHandle = await lookupPeerIdsByHandle(input.thenvoiRest, input.roomId, missingHandles);
+  } catch (error) {
+    if (error instanceof UnsupportedFeatureError) {
+      input.logger.warn("linear_thenvoi_bridge.peer_lookup_unavailable", {
+        roomId: input.roomId,
+        missingHandles,
+        reason: error.message
+      });
+      return;
+    }
+    throw error;
+  }
+  for (const handle of missingHandles) {
+    const participantId = peersByHandle.get(handle);
+    if (!participantId) {
+      input.logger.warn("linear_thenvoi_bridge.peer_not_found", {
+        roomId: input.roomId,
+        handle
+      });
+      continue;
+    }
+    try {
+      await input.thenvoiRest.addChatParticipant(
+        input.roomId,
+        {
+          participantId,
+          role: "member"
+        }
+      );
+    } catch (error) {
+      input.logger.warn("linear_thenvoi_bridge.add_participant_failed", {
+        roomId: input.roomId,
+        handle,
+        error: error instanceof Error ? error.message : String(error)
+      });
+      if (!isRetryableRateLimitError(error)) {
+        throw error;
+      }
+    }
+  }
+}
+async function lookupPeerIdsByHandle(thenvoiRest, roomId, handles) {
+  if (!thenvoiRest.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({
+      page,
+      pageSize: PEER_PAGE_SIZE,
+      notInChat: roomId
+    });
+    for (const peer of response.data) {
+      const peerId = peer.id;
+      if (typeof peerId !== "string" || peerId.length === 0) {
+        continue;
+      }
+      const handleCandidates = [
+        typeof peer.handle === "string" ? stripHandlePrefix(peer.handle) : "",
+        typeof peer.name === "string" ? stripHandlePrefix(peer.name) : ""
+      ].filter((value) => value.length > 0);
+      for (const candidate of handleCandidates) {
+        if (!targets.has(candidate)) {
+          continue;
+        }
+        found.set(candidate, peerId);
+      }
+    }
+    if (response.data.length < PEER_PAGE_SIZE) {
+      break;
+    }
+  }
+  return found;
+}
+async function selectRelevantPeerHandles(input) {
+  const configuredHandles = resolveConfiguredSpecialistHandles(input.intent, {
+    planningAgentHandles: input.planningAgentHandles,
+    implementationAgentHandles: input.implementationAgentHandles
+  }).filter((handle) => handle !== input.hostAgentHandle);
+  if (configuredHandles.length > 0) {
+    input.logger.info("linear_thenvoi_bridge.peer_prefetch_selected", {
+      roomId: input.roomId,
+      intent: input.intent,
+      handles: configuredHandles,
+      source: "configured"
+    });
+    return configuredHandles;
+  }
+  if (!input.thenvoiRest.listPeers) {
+    return [];
+  }
+  let peers;
+  try {
+    const response = await input.thenvoiRest.listPeers({
+      page: 1,
+      pageSize: PEER_PAGE_SIZE,
+      notInChat: input.roomId
+    });
+    peers = response.data;
+  } catch (error) {
+    if (error instanceof UnsupportedFeatureError) {
+      return [];
+    }
+    input.logger.warn("linear_thenvoi_bridge.peer_prefetch_failed", {
+      roomId: input.roomId,
+      intent: input.intent,
+      error: error instanceof Error ? error.message : String(error)
+    });
+    return [];
+  }
+  const ranked = peers.map((peer) => {
+    const handle = normalizeOptionalHandle(typeof peer.handle === "string" ? peer.handle : null);
+    return {
+      handle,
+      score: scorePeerForIntent(peer, input.intent)
+    };
+  }).filter(
+    (candidate) => typeof candidate.handle === "string" && candidate.handle.length > 0 && candidate.handle !== input.hostAgentHandle
+  ).filter((candidate) => candidate.score > 0).sort((left, right) => right.score - left.score);
+  const selected = ranked.slice(0, 2).map((candidate) => candidate.handle);
+  if (selected.length > 0) {
+    input.logger.info("linear_thenvoi_bridge.peer_prefetch_selected", {
+      roomId: input.roomId,
+      intent: input.intent,
+      handles: selected,
+      source: "lookup"
+    });
+  }
+  return selected;
+}
+function resolveConfiguredSpecialistHandles(intent, config) {
+  const handles = intent === "implementation" ? config.implementationAgentHandles : config.planningAgentHandles;
+  if (!handles || handles.length === 0) {
+    return [];
+  }
+  const configured = handles.map((value) => normalizeOptionalHandle(value)).filter((value) => Boolean(value));
+  if (intent === "implementation") {
+    return dedupeHandles(configured);
+  }
+  const ranked = configured.map((handle) => ({
+    handle,
+    score: /\bplanner\b/.test(handle) ? 3 : /\breviewer\b|\bcodex\b/.test(handle) ? 2 : 1
+  })).sort((left, right) => right.score - left.score).slice(0, 2).map((entry) => entry.handle);
+  return dedupeHandles(ranked);
+}
+function scorePeerForIntent(peer, intent) {
+  const description = typeof peer.description === "string" ? peer.description : "";
+  const haystack = [
+    typeof peer.name === "string" ? peer.name : "",
+    typeof peer.handle === "string" ? peer.handle : "",
+    description
+  ].join(" ").toLowerCase();
+  const weightedTerms = intent === "implementation" ? [
+    { pattern: /\bimplementer\b|\bimplementation\b/, score: 10 },
+    { pattern: /\bengineer\b|\bdeveloper\b|\bcoder\b|\bcoding\b/, score: 8 },
+    { pattern: /\bbuild\b|\bfrontend\b|\bui\b/, score: 5 },
+    { pattern: /\breviewer\b|\breview\b|\bplanner\b|\bplan\b/, score: -4 }
+  ] : [
+    { pattern: /\bplanner\b|\bplanning\b|\bplan\b/, score: 10 },
+    { pattern: /\bclaude\b/, score: 8 },
+    { pattern: /\breviewer\b|\breview\b|\bcodex\b/, score: 7 },
+    { pattern: /\borchestrator\b|\barchitect\b|\bdesign\b|\bscope\b|\bspec\b/, score: 6 },
+    { pattern: /\bimplementer\b|\bimplementation\b/, score: -3 }
+  ];
+  return weightedTerms.reduce((total, term) => term.pattern.test(haystack) ? total + term.score : total, 0);
+}
+async function sleep(ms) {
+  await new Promise((resolveDelay) => setTimeout(resolveDelay, ms));
+}
+async function saveSessionRecord(store, record) {
+  await store.upsert(record);
+}
+
+// src/integrations/linear/client.ts
+var import_sdk3 = require("@linear/sdk");
+function isLinearApiKey(token) {
+  return token.trim().startsWith("lin_api_");
+}
+function createLinearClient(token) {
+  const trimmedToken = token.trim();
+  if (isLinearApiKey(trimmedToken)) {
+    return new import_sdk3.LinearClient({
+      apiKey: trimmedToken
+    });
+  }
+  return new import_sdk3.LinearClient({
+    accessToken: trimmedToken
+  });
+}
+function buildLinearAuthorizationHeader(token) {
+  const trimmedToken = token.trim();
+  if (isLinearApiKey(trimmedToken)) {
+    return trimmedToken;
+  }
+  if (trimmedToken.startsWith("Bearer ")) {
+    return trimmedToken;
+  }
+  return `Bearer ${trimmedToken}`;
+}
+
+// src/integrations/linear/store.ts
+var SESSION_STATUSES = /* @__PURE__ */ new Set([
+  "active",
+  "waiting",
+  "completed",
+  "canceled",
+  "errored"
+]);
+var SqliteSessionRoomStore = class {
+  dbPath;
+  dbPromise = null;
+  constructor(dbPath) {
+    this.dbPath = dbPath;
+  }
+  async getBySessionId(sessionId) {
+    const db = await this.getDb();
+    const rawRow = db.prepare(
+      `
+        SELECT
+          linear_session_id,
+          linear_issue_id,
+          thenvoi_room_id,
+          status,
+          last_event_key,
+          created_at,
+          updated_at
+        FROM linear_thenvoi_session_rooms
+        WHERE linear_session_id = ?
+        LIMIT 1
+        `
+    ).get(sessionId);
+    const row = parseSessionRoomRow(rawRow);
+    return row ? this.toRecord(row) : null;
+  }
+  async getByIssueId(issueId) {
+    const db = await this.getDb();
+    const rawRow = db.prepare(
+      `
+        SELECT
+          linear_session_id,
+          linear_issue_id,
+          thenvoi_room_id,
+          status,
+          last_event_key,
+          created_at,
+          updated_at
+        FROM linear_thenvoi_session_rooms
+        WHERE linear_issue_id = ? AND status != 'canceled'
+        ORDER BY updated_at DESC
+        LIMIT 1
+        `
+    ).get(issueId);
+    const row = parseSessionRoomRow(rawRow);
+    return row ? this.toRecord(row) : null;
+  }
+  async upsert(record) {
+    const db = await this.getDb();
+    db.prepare(
+      `
+        INSERT INTO linear_thenvoi_session_rooms (
+          linear_session_id,
+          linear_issue_id,
+          thenvoi_room_id,
+          status,
+          last_event_key,
+          created_at,
+          updated_at
+        ) 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,
+          updated_at = excluded.updated_at
+        `
+    ).run(
+      record.linearSessionId,
+      record.linearIssueId,
+      record.thenvoiRoomId,
+      record.status,
+      record.lastEventKey ?? null,
+      record.createdAt,
+      record.updatedAt
+    );
+  }
+  async markCanceled(sessionId) {
+    const db = await this.getDb();
+    db.prepare(
+      `
+        UPDATE linear_thenvoi_session_rooms
+        SET status = 'canceled', updated_at = ?
+        WHERE linear_session_id = ?
+        `
+    ).run((/* @__PURE__ */ new Date()).toISOString(), sessionId);
+  }
+  async enqueueBootstrapRequest(request) {
+    const db = await this.getDb();
+    db.prepare(
+      `
+        INSERT INTO linear_thenvoi_bootstrap_requests (
+          event_key,
+          linear_session_id,
+          thenvoi_room_id,
+          expected_content,
+          message_type,
+          metadata_json,
+          created_at,
+          expires_at,
+          processed_at
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, NULL)
+        ON CONFLICT(event_key)
+        DO UPDATE SET
+          linear_session_id = excluded.linear_session_id,
+          thenvoi_room_id = excluded.thenvoi_room_id,
+          expected_content = excluded.expected_content,
+          message_type = excluded.message_type,
+          metadata_json = excluded.metadata_json,
+          created_at = excluded.created_at,
+          expires_at = excluded.expires_at,
+          processed_at = NULL
+        `
+    ).run(
+      request.eventKey,
+      request.linearSessionId,
+      request.thenvoiRoomId,
+      request.expectedContent,
+      request.messageType,
+      request.metadata ? JSON.stringify(request.metadata) : null,
+      request.createdAt,
+      request.expiresAt
+    );
+  }
+  async listPendingBootstrapRequests(limit = 20) {
+    const db = await this.getDb();
+    const rawRows = db.prepare(
+      `
+        SELECT
+          event_key,
+          linear_session_id,
+          thenvoi_room_id,
+          expected_content,
+          message_type,
+          metadata_json,
+          created_at,
+          expires_at,
+          processed_at
+        FROM linear_thenvoi_bootstrap_requests
+        WHERE processed_at IS NULL AND expires_at > ?
+        ORDER BY created_at ASC
+        LIMIT ?
+        `
+    ).all((/* @__PURE__ */ new Date()).toISOString(), limit);
+    const rows = parseBootstrapRequestRows(rawRows);
+    return rows.map((row) => ({
+      eventKey: row.event_key,
+      linearSessionId: row.linear_session_id,
+      thenvoiRoomId: row.thenvoi_room_id,
+      expectedContent: row.expected_content,
+      messageType: row.message_type,
+      metadata: this.parseMetadata(row.metadata_json),
+      createdAt: row.created_at,
+      expiresAt: row.expires_at
+    }));
+  }
+  async markBootstrapRequestProcessed(eventKey) {
+    const db = await this.getDb();
+    db.prepare(
+      `
+        UPDATE linear_thenvoi_bootstrap_requests
+        SET processed_at = ?
+        WHERE event_key = ? AND processed_at IS NULL
+        `
+    ).run((/* @__PURE__ */ new Date()).toISOString(), eventKey);
+  }
+  async close() {
+    if (!this.dbPromise) {
+      return;
+    }
+    const db = await this.dbPromise;
+    db.close();
+    this.dbPromise = null;
+  }
+  async getDb() {
+    if (this.dbPromise) {
+      return this.dbPromise;
+    }
+    this.dbPromise = this.initialize();
+    return this.dbPromise;
+  }
+  async initialize() {
+    const module2 = await import("sqlite").catch((error) => {
+      throw new UnsupportedFeatureError(
+        `SQLite store requires node:sqlite (Node.js 22+). Original error: ${error instanceof Error ? error.message : String(error)}`
+      );
+    });
+    const db = new module2.DatabaseSync(this.dbPath);
+    db.exec(`
+        CREATE TABLE IF NOT EXISTS linear_thenvoi_session_rooms (
+          linear_session_id TEXT PRIMARY KEY,
+          linear_issue_id TEXT,
+          thenvoi_room_id TEXT NOT NULL,
+          status TEXT NOT NULL,
+          last_event_key TEXT,
+          created_at TEXT NOT NULL,
+          updated_at TEXT NOT NULL
+        );
+
+      CREATE INDEX IF NOT EXISTS idx_linear_thenvoi_session_rooms_issue_active
+      ON linear_thenvoi_session_rooms (linear_issue_id, status, updated_at);
+
+      CREATE TABLE IF NOT EXISTS linear_thenvoi_bootstrap_requests (
+        event_key TEXT PRIMARY KEY,
+        linear_session_id TEXT NOT NULL,
+        thenvoi_room_id TEXT NOT NULL,
+        expected_content TEXT NOT NULL,
+        message_type TEXT NOT NULL,
+        metadata_json TEXT,
+        created_at TEXT NOT NULL,
+        expires_at TEXT NOT NULL,
+        processed_at TEXT
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_linear_thenvoi_bootstrap_requests_pending
+      ON linear_thenvoi_bootstrap_requests (processed_at, expires_at, created_at);
+    `);
+    try {
+      db.exec(`
+        ALTER TABLE linear_thenvoi_session_rooms
+        ADD COLUMN last_event_key TEXT
+      `);
+    } catch (error) {
+      if (!isDuplicateColumnError(error)) {
+        throw error;
+      }
+    }
+    try {
+      db.exec(`
+        ALTER TABLE linear_thenvoi_bootstrap_requests
+        ADD COLUMN message_type TEXT NOT NULL DEFAULT 'task'
+      `);
+    } catch (error) {
+      if (!isDuplicateColumnError(error)) {
+        throw error;
+      }
+    }
+    try {
+      db.exec(`
+        ALTER TABLE linear_thenvoi_bootstrap_requests
+        ADD COLUMN metadata_json 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,
+      status: row.status,
+      lastEventKey: row.last_event_key,
+      createdAt: row.created_at,
+      updatedAt: row.updated_at
+    };
+  }
+  parseMetadata(metadataJson) {
+    if (!metadataJson) {
+      return void 0;
+    }
+    try {
+      const parsed = JSON.parse(metadataJson);
+      return asRecord(parsed) ?? void 0;
+    } catch (error) {
+      const msg = error instanceof Error ? error.message : String(error);
+      console.warn(`SqliteSessionRoomStore: failed to parse metadata_json: ${msg}`);
+      return void 0;
+    }
+  }
+};
+function asRecord(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return null;
+  }
+  return value;
+}
+function isDuplicateColumnError(error) {
+  if (!(error instanceof Error)) {
+    return false;
+  }
+  return /duplicate column name/i.test(error.message);
+}
+function asString(value) {
+  return typeof value === "string" ? value : null;
+}
+function asNullableString(value) {
+  if (value === null) {
+    return null;
+  }
+  if (value === void 0) {
+    return void 0;
+  }
+  return asString(value);
+}
+function isSessionStatus(value) {
+  return SESSION_STATUSES.has(value);
+}
+function parseSessionRoomRow(value) {
+  const row = asRecord(value);
+  if (!row) {
+    return null;
+  }
+  const linearSessionId = asString(row.linear_session_id);
+  const linearIssueId = asNullableString(row.linear_issue_id);
+  const thenvoiRoomId = asString(row.thenvoi_room_id);
+  const status = asString(row.status);
+  const lastEventKey = asNullableString(row.last_event_key);
+  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) {
+    return null;
+  }
+  return {
+    linear_session_id: linearSessionId,
+    linear_issue_id: linearIssueId,
+    thenvoi_room_id: thenvoiRoomId,
+    status,
+    last_event_key: lastEventKey,
+    created_at: createdAt,
+    updated_at: updatedAt
+  };
+}
+function parseBootstrapRequestRows(value) {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  return value.map((entry) => parseBootstrapRequestRow(entry)).filter((entry) => entry !== null);
+}
+function parseBootstrapRequestRow(value) {
+  const row = asRecord(value);
+  if (!row) {
+    return null;
+  }
+  const eventKey = asString(row.event_key);
+  const linearSessionId = asString(row.linear_session_id);
+  const thenvoiRoomId = 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) {
+    return null;
+  }
+  return {
+    event_key: eventKey,
+    linear_session_id: linearSessionId,
+    thenvoi_room_id: thenvoiRoomId,
+    expected_content: expectedContent,
+    message_type: messageType,
+    metadata_json: metadataJson,
+    created_at: createdAt,
+    expires_at: expiresAt,
+    processed_at: processedAt
+  };
+}
+function createSqliteSessionRoomStore(dbPath) {
+  return new SqliteSessionRoomStore(dbPath);
+}
+
+// src/integrations/linear/tools.ts
+var import_zod = require("zod");
+function createLinearTools(options) {
+  const { client, store, enableElicitation = true } = 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")
+  });
+  const issueIdInputSchema = import_zod.z.object({
+    issue_id: import_zod.z.string().optional().describe("The Linear issue ID (UUID) from the session context")
+  }).passthrough();
+  const issueCommentLimitSchema = import_zod.z.number().int().min(1).max(50).optional().describe("Maximum number of recent comments to return");
+  const requiredIssueIdSchema = issueIdInputSchema;
+  const optionalIssueIdSchema = issueIdInputSchema;
+  const tools = [];
+  const addSessionBodyTool = (name, description, handler) => {
+    tools.push({
+      name,
+      description,
+      schema: sessionBodySchema,
+      handler
+    });
+  };
+  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 };
+    }
+  );
+  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 };
+    }
+  );
+  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 };
+    }
+  );
+  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);
+        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) => {
+      await completeLinearSession({
+        linearClient: client,
+        agentSessionId: args.session_id,
+        body: args.body,
+        store
+      });
+      return { ok: true };
+    }
+  );
+  tools.push(
+    {
+      name: "linear_update_plan",
+      description: "Update the plan for the Linear agent session, showing progress on each step.",
+      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({
+          title: import_zod.z.string().describe("Step title"),
+          status: import_zod.z.enum(["pending", "in_progress", "completed", "failed"]).describe("Step status")
+        })).describe("The plan steps with their current status")
+      }),
+      handler: async (args) => {
+        await updatePlan(
+          client,
+          args.session_id,
+          args.steps
+        );
+        return { ok: true };
+      }
+    }
+  );
+  addIssueTools({
+    tools,
+    client,
+    requiredIssueIdSchema,
+    optionalIssueIdSchema,
+    issueCommentLimitSchema
+  });
+  return tools;
+}
+function addIssueTools(input) {
+  const {
+    tools,
+    client,
+    requiredIssueIdSchema,
+    optionalIssueIdSchema,
+    issueCommentLimitSchema
+  } = input;
+  tools.push(
+    {
+      name: "linear_get_issue",
+      description: "Fetch the current Linear issue details using the exact issue UUID from the session context.",
+      schema: requiredIssueIdSchema,
+      handler: async (args) => {
+        const issueId = resolveIssueId("linear_get_issue", args);
+        return readIssue(client, issueId);
+      }
+    },
+    {
+      name: "linear_list_issue_comments",
+      description: "List recent comments for the current Linear issue using the exact issue UUID from the session context.",
+      schema: requiredIssueIdSchema.extend({ limit: issueCommentLimitSchema }),
+      handler: async (args) => {
+        const issueId = resolveIssueId("linear_list_issue_comments", args);
+        return readIssueComments(client, issueId, typeof args.limit === "number" ? args.limit : 20);
+      }
+    },
+    {
+      name: "linear_list_workflow_states",
+      description: "List workflow states for the current issue's team so the bridge can move the issue between Todo, In Progress, In Review, and Done.",
+      schema: optionalIssueIdSchema.extend({
+        team_id: import_zod.z.string().optional().describe("The Linear team ID when already known from the issue context")
+      }),
+      handler: async (args) => {
+        const issueId = resolveOptionalIssueId("linear_list_workflow_states", args);
+        const teamId = typeof args.team_id === "string" && args.team_id.trim().length > 0 ? args.team_id : await readIssueTeamId(client, issueId);
+        if (!teamId) {
+          throw new Error("linear_list_workflow_states requires issue_id or team_id.");
+        }
+        return readWorkflowStates(client, teamId);
+      }
+    },
+    {
+      name: "linear_update_issue",
+      description: "Update a Linear issue (title/description/state/assignee/priority/etc.) from the session workflow.",
+      schema: requiredIssueIdSchema.extend({
+        title: import_zod.z.string().optional().describe("New issue title"),
+        description: import_zod.z.string().optional().describe("New issue description (Markdown)"),
+        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"),
+        estimate: import_zod.z.number().int().optional().describe("Estimate points"),
+        due_date: import_zod.z.string().optional().describe("Due date ISO string")
+      }),
+      handler: async (args) => {
+        if (typeof client.updateIssue !== "function") {
+          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;
+        if (!hasUpdates) {
+          throw new Error("linear_update_issue requires at least one update field.");
+        }
+        await client.updateIssue(
+          issueId,
+          {
+            ...args.title !== void 0 ? { title: args.title } : {},
+            ...args.description !== void 0 ? { description: args.description } : {},
+            ...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.estimate !== void 0 ? { estimate: args.estimate } : {},
+            ...args.due_date !== void 0 ? { dueDate: args.due_date } : {}
+          }
+        );
+        return { ok: true };
+      }
+    },
+    {
+      name: "linear_add_issue_comment",
+      description: "Add a new comment to a Linear issue.",
+      schema: requiredIssueIdSchema.extend({
+        body: import_zod.z.string().describe("Comment body (Markdown)")
+      }),
+      handler: async (args) => {
+        if (typeof client.createComment !== "function") {
+          throw new Error("linear_add_issue_comment is unavailable: Linear client does not support createComment().");
+        }
+        const issueId = resolveIssueId("linear_add_issue_comment", args);
+        await client.createComment({
+          issueId,
+          body: args.body
+        });
+        return { ok: true };
+      }
+    }
+  );
+}
+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}".`);
+  }
+}
+function resolveIssueId(toolName, args) {
+  const issueId = resolveOptionalIssueId(toolName, args);
+  if (!issueId) {
+    throw new Error(`${toolName} requires issue_id.`);
+  }
+  return issueId;
+}
+function resolveOptionalIssueId(toolName, args) {
+  if (typeof args.issue_id !== "string" || args.issue_id.length === 0) {
+    return void 0;
+  }
+  assertUuid(toolName, args.issue_id);
+  return args.issue_id;
+}
+async function readIssue(client, issueId) {
+  if (typeof client.issue !== "function") {
+    throw new Error("linear_get_issue is unavailable: Linear client does not support issue().");
+  }
+  const issue = await client.issue(issueId);
+  return {
+    issue: {
+      id: issue.id,
+      identifier: issue.identifier ?? null,
+      title: issue.title ?? null,
+      description: issue.description ?? null,
+      url: issue.url ?? null,
+      priority: issue.priority ?? null,
+      estimate: issue.estimate ?? null,
+      due_date: issue.dueDate ?? null,
+      created_at: issue.createdAt ?? null,
+      updated_at: issue.updatedAt ?? null,
+      state: issue.state ? {
+        id: issue.state.id ?? null,
+        name: issue.state.name ?? null,
+        type: issue.state.type ?? null
+      } : null,
+      assignee: issue.assignee ? {
+        id: issue.assignee.id ?? null,
+        name: issue.assignee.displayName ?? issue.assignee.name ?? null
+      } : null,
+      team: issue.team ? {
+        id: issue.team.id ?? null,
+        key: issue.team.key ?? null,
+        name: issue.team.name ?? null
+      } : null
+    }
+  };
+}
+async function readIssueComments(client, issueId, limit) {
+  if (typeof client.issue !== "function") {
+    throw new Error("linear_list_issue_comments is unavailable: Linear client does not support issue().");
+  }
+  const issue = await client.issue(issueId);
+  if (typeof issue.comments !== "function") {
+    throw new Error("linear_list_issue_comments is unavailable: issue.comments() is not supported by the Linear client.");
+  }
+  const response = await issue.comments();
+  const comments = (response.nodes ?? []).slice(-limit).map((comment) => ({
+    id: comment.id ?? null,
+    body: comment.body ?? null,
+    created_at: comment.createdAt ?? null,
+    updated_at: comment.updatedAt ?? null,
+    user: comment.user ? {
+      id: comment.user.id ?? null,
+      name: comment.user.displayName ?? comment.user.name ?? null
+    } : null
+  }));
+  return { comments };
+}
+async function readIssueTeamId(client, issueId) {
+  if (!issueId) {
+    return null;
+  }
+  if (typeof client.issue !== "function") {
+    throw new Error("linear_list_workflow_states is unavailable: Linear client does not support issue().");
+  }
+  const issue = await client.issue(issueId);
+  return issue.teamId ?? issue.team?.id ?? null;
+}
+async function readWorkflowStates(client, teamId) {
+  if (typeof client.workflowStates !== "function") {
+    throw new Error(
+      "linear_list_workflow_states is unavailable: Linear client does not support workflowStates()."
+    );
+  }
+  const response = await client.workflowStates({ teamId });
+  const states = (response.nodes ?? []).map((state) => ({
+    id: state.id ?? null,
+    name: state.name ?? null,
+    type: state.type ?? null,
+    position: state.position ?? null,
+    team_id: state.teamId ?? teamId
+  })).sort((left, right) => (left.position ?? Number.MAX_SAFE_INTEGER) - (right.position ?? Number.MAX_SAFE_INTEGER));
+  return { team_id: teamId, states };
+}
+
+// src/integrations/linear/webhook.ts
+var import_webhooks = require("@linear/sdk/webhooks");
+var DISPATCH_RETRY_LIMIT = 2;
+var DISPATCH_RETRY_BASE_DELAY_MS = 1e3;
+function createInlineLinearBridgeDispatcher(options) {
+  const logger = options?.logger ?? new NoopLogger();
+  const runtime = createLinearBridgeRuntime();
+  return {
+    dispatch: async (job) => {
+      const result = await runDispatchAttempt(async () => {
+        await handleAgentSessionEvent(job.input, {
+          skipAcknowledgment: true,
+          expectedEventKey: job.eventKey,
+          runtime: job.runtime ?? runtime
+        });
+      }, {
+        logger,
+        failureEvent: "linear_thenvoi_bridge.dispatch_failed",
+        retryEvent: "linear_thenvoi_bridge.dispatch_retrying",
+        eventKey: job.eventKey,
+        sessionId: job.input.payload.agentSession.id
+      });
+      if (result.ok) {
+        await markBootstrapHandoffProcessed({
+          eventKey: job.eventKey,
+          store: job.input.deps.store,
+          logger,
+          sessionId: job.input.payload.agentSession.id
+        });
+        return;
+      }
+      const failure = {
+        eventKey: job.eventKey,
+        sessionId: job.input.payload.agentSession.id,
+        attempts: result.attempts,
+        error: result.error
+      };
+      await signalTerminalDispatchFailure({
+        logger,
+        job,
+        failure
+      });
+      throw result.error;
+    }
+  };
+}
+function createInProcessLinearBridgeDispatcher(options) {
+  const logger = options?.logger ?? new NoopLogger();
+  const runtime = createLinearBridgeRuntime();
+  const queued = /* @__PURE__ */ new Set();
+  const inFlight = /* @__PURE__ */ new Set();
+  const terminalFailures = [];
+  return {
+    isQueued: (eventKey) => queued.has(eventKey),
+    waitForIdle: async () => {
+      let snapshot = [...inFlight];
+      while (snapshot.length > 0) {
+        await Promise.allSettled(snapshot);
+        snapshot = [...inFlight];
+      }
+      if (terminalFailures.length === 0) {
+        return;
+      }
+      const failures = terminalFailures.splice(0, terminalFailures.length);
+      throw new AggregateError(
+        failures.map((failure) => toDispatchFailureError(failure)),
+        `Linear bridge async dispatch failed for ${failures.length} event(s)`
+      );
+    },
+    dispatch: async (job) => {
+      if (queued.has(job.eventKey)) {
+        return;
+      }
+      queued.add(job.eventKey);
+      const dispatchTask = (async () => {
+        await new Promise((resolveMicrotask) => {
+          queueMicrotask(() => resolveMicrotask());
+        });
+        const result = await runDispatchAttempt(async () => {
+          await handleAgentSessionEvent(job.input, {
+            skipAcknowledgment: true,
+            expectedEventKey: job.eventKey,
+            runtime: job.runtime ?? runtime
+          });
+        }, {
+          logger,
+          failureEvent: "linear_thenvoi_bridge.async_dispatch_failed",
+          retryEvent: "linear_thenvoi_bridge.async_dispatch_retrying",
+          eventKey: job.eventKey,
+          sessionId: job.input.payload.agentSession.id
+        });
+        if (result.ok) {
+          await markBootstrapHandoffProcessed({
+            eventKey: job.eventKey,
+            store: job.input.deps.store,
+            logger,
+            sessionId: job.input.payload.agentSession.id
+          });
+          return;
+        }
+        const failure = {
+          eventKey: job.eventKey,
+          sessionId: job.input.payload.agentSession.id,
+          attempts: result.attempts,
+          error: result.error
+        };
+        terminalFailures.push(failure);
+        await signalTerminalDispatchFailure({
+          logger,
+          job,
+          failure
+        });
+      })();
+      inFlight.add(dispatchTask);
+      void dispatchTask.catch((error) => {
+        logger.error("linear_thenvoi_bridge.async_dispatch_failure_signal_crashed", {
+          eventKey: job.eventKey,
+          sessionId: job.input.payload.agentSession.id,
+          error: serializeError(error)
+        });
+      }).finally(() => {
+        queued.delete(job.eventKey);
+        inFlight.delete(dispatchTask);
+      });
+      await dispatchTask;
+    }
+  };
+}
+function createLinearWebhookHandler(options) {
+  const logger = options.deps.logger ?? new NoopLogger();
+  const runtime = createLinearBridgeRuntime();
+  const dispatcher = options.dispatcher ?? createInlineLinearBridgeDispatcher({ logger });
+  const webhookClient = new import_webhooks.LinearWebhookClient(options.config.linearWebhookSecret);
+  const inFlightEventKeys = /* @__PURE__ */ new Set();
+  return async (request, response) => {
+    if (request.method !== "POST") {
+      logger.warn("linear_thenvoi_bridge.webhook_invalid_method", {
+        method: request.method ?? null
+      });
+      sendText(response, 405, "Method not allowed");
+      return;
+    }
+    const signature = getHeaderValue(request, import_webhooks.LINEAR_WEBHOOK_SIGNATURE_HEADER);
+    if (!signature) {
+      logger.warn("linear_thenvoi_bridge.webhook_missing_signature", {});
+      sendText(response, 400, "Missing webhook signature");
+      return;
+    }
+    const timestamp = getHeaderValue(request, import_webhooks.LINEAR_WEBHOOK_TS_HEADER);
+    if (!timestamp) {
+      logger.warn("linear_thenvoi_bridge.webhook_missing_timestamp", {});
+      sendText(response, 400, "Missing webhook timestamp");
+      return;
+    }
+    const rawBody = await readRawBody(request);
+    let payload;
+    try {
+      payload = webhookClient.parseData(
+        rawBody,
+        signature,
+        timestamp
+      );
+    } catch (error) {
+      logger.warn("linear_thenvoi_bridge.webhook_invalid_signature", {
+        error: error instanceof Error ? error.message : String(error)
+      });
+      sendText(response, 400, "Invalid webhook");
+      return;
+    }
+    if (payload.type !== "AgentSessionEvent") {
+      logger.info("linear_thenvoi_bridge.webhook_ignored_event", {
+        type: payload.type
+      });
+      sendText(response, 200, "OK");
+      return;
+    }
+    const eventKey = getAgentSessionEventKey(payload);
+    logger.info("linear_thenvoi_bridge.webhook_received", {
+      sessionId: payload.agentSession.id,
+      issueId: payload.agentSession.issue?.id ?? null,
+      action: payload.action,
+      eventKey
+    });
+    const existing = await options.deps.store.getBySessionId(payload.agentSession.id);
+    const alreadyInFlight = inFlightEventKeys.has(eventKey);
+    if (existing?.lastEventKey === eventKey || alreadyInFlight || dispatcher.isQueued?.(eventKey)) {
+      logger.info("linear_thenvoi_bridge.webhook_duplicate_ignored", {
+        sessionId: payload.agentSession.id,
+        eventKey
+      });
+      sendText(response, 200, "OK");
+      return;
+    }
+    inFlightEventKeys.add(eventKey);
+    try {
+      if (normalizeAction2(payload.action) === "created") {
+        try {
+          await postThought(
+            options.deps.linearClient,
+            payload.agentSession.id,
+            "Received session. Setting up workspace..."
+          );
+        } catch (error) {
+          logger.warn("linear_thenvoi_bridge.webhook_acknowledgment_failed", {
+            sessionId: payload.agentSession.id,
+            error
+          });
+        }
+      }
+      await dispatcher.dispatch({
+        eventKey,
+        runtime,
+        input: {
+          payload,
+          config: options.config,
+          deps: options.deps
+        }
+      });
+    } catch (error) {
+      logger.error("linear_thenvoi_bridge.webhook_dispatch_failed", {
+        sessionId: payload.agentSession.id,
+        issueId: payload.agentSession.issue?.id ?? null,
+        action: payload.action,
+        eventKey,
+        error: serializeError(error)
+      });
+      sendText(response, isRetryableDispatchError(error) ? 503 : 500, "Dispatch failed");
+      return;
+    } finally {
+      inFlightEventKeys.delete(eventKey);
+    }
+    logger.info("linear_thenvoi_bridge.webhook_dispatched", {
+      sessionId: payload.agentSession.id,
+      issueId: payload.agentSession.issue?.id ?? null,
+      action: payload.action,
+      eventKey
+    });
+    sendText(response, 200, "OK");
+  };
+}
+function normalizeAction2(action) {
+  return typeof action === "string" ? action.trim().toLowerCase() : "";
+}
+function getHeaderValue(request, name) {
+  const value = request.headers[name];
+  if (Array.isArray(value)) {
+    return value[0] ?? null;
+  }
+  return typeof value === "string" ? value : null;
+}
+async function readRawBody(request) {
+  if (Buffer.isBuffer(request.body)) {
+    return request.body;
+  }
+  if (typeof request.body === "string") {
+    return Buffer.from(request.body);
+  }
+  if (request.body instanceof Uint8Array) {
+    return Buffer.from(request.body);
+  }
+  const chunks = [];
+  for await (const chunk of request) {
+    if (typeof chunk === "string") {
+      chunks.push(Buffer.from(chunk));
+    } else {
+      chunks.push(Buffer.from(chunk));
+    }
+  }
+  return Buffer.concat(chunks);
+}
+function sendText(response, statusCode, body) {
+  if (response.headersSent) {
+    return;
+  }
+  response.statusCode = statusCode;
+  response.end(body);
+}
+async function runDispatchAttempt(task, context) {
+  const retryLimit = context.retryLimit ?? DISPATCH_RETRY_LIMIT;
+  const retryBaseDelayMs = context.retryBaseDelayMs ?? DISPATCH_RETRY_BASE_DELAY_MS;
+  let attempt = 0;
+  while (true) {
+    try {
+      await task();
+      return { ok: true };
+    } catch (error) {
+      if (!isRetryableDispatchError(error) || attempt >= retryLimit) {
+        context.logger.error(context.failureEvent, {
+          eventKey: context.eventKey,
+          sessionId: context.sessionId,
+          error: serializeError(error)
+        });
+        return {
+          ok: false,
+          attempts: attempt + 1,
+          error
+        };
+      }
+      attempt += 1;
+      context.logger.warn(context.retryEvent, {
+        eventKey: context.eventKey,
+        sessionId: context.sessionId,
+        attempt,
+        delayMs: retryBaseDelayMs * attempt,
+        error: serializeError(error)
+      });
+      await sleep2(retryBaseDelayMs * attempt);
+    }
+  }
+}
+async function markBootstrapHandoffProcessed(input) {
+  try {
+    await input.store.markBootstrapRequestProcessed(input.eventKey);
+  } catch (error) {
+    input.logger.warn("linear_thenvoi_bridge.bootstrap_handoff_mark_processed_failed", {
+      eventKey: input.eventKey,
+      sessionId: input.sessionId,
+      error: serializeError(error)
+    });
+  }
+}
+async function signalTerminalDispatchFailure(input) {
+  const { logger, job, failure } = input;
+  try {
+    const existing = await job.input.deps.store.getBySessionId(failure.sessionId);
+    if (existing) {
+      await job.input.deps.store.upsert({
+        ...existing,
+        status: "errored",
+        lastEventKey: job.eventKey,
+        updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      logger.warn("linear_thenvoi_bridge.async_dispatch_terminal_failure_signaled", {
+        eventKey: failure.eventKey,
+        sessionId: failure.sessionId,
+        attempts: failure.attempts,
+        signal: "session_store_status_errored"
+      });
+      return;
+    }
+  } catch (storeError) {
+    logger.error("linear_thenvoi_bridge.async_dispatch_terminal_failure_store_signal_failed", {
+      eventKey: failure.eventKey,
+      sessionId: failure.sessionId,
+      attempts: failure.attempts,
+      dispatchError: serializeError(failure.error),
+      signalError: serializeError(storeError)
+    });
+  }
+  try {
+    await postError(
+      job.input.deps.linearClient,
+      failure.sessionId,
+      "Bridge dispatch failed and could not recover automatically. Retry this session event in Linear."
+    );
+    logger.warn("linear_thenvoi_bridge.async_dispatch_terminal_failure_signaled", {
+      eventKey: failure.eventKey,
+      sessionId: failure.sessionId,
+      attempts: failure.attempts,
+      signal: "linear_activity_error"
+    });
+  } catch (signalError) {
+    logger.error("linear_thenvoi_bridge.async_dispatch_terminal_failure_signal_failed", {
+      eventKey: failure.eventKey,
+      sessionId: failure.sessionId,
+      attempts: failure.attempts,
+      dispatchError: serializeError(failure.error),
+      signalError: serializeError(signalError)
+    });
+  }
+}
+function isRetryableDispatchError(error) {
+  return typeof error === "object" && error !== null && "retryable" in error && error.retryable === true;
+}
+async function sleep2(ms) {
+  await new Promise((resolveDelay) => setTimeout(resolveDelay, ms));
+}
+function serializeError(error) {
+  if (error instanceof Error) {
+    return {
+      name: error.name,
+      message: error.message,
+      stack: error.stack,
+      ...typeof error.retryable !== "undefined" ? { retryable: error.retryable } : {}
+    };
+  }
+  return {
+    message: String(error)
+  };
+}
+function toDispatchFailureError(failure) {
+  return new Error(
+    `Linear bridge async dispatch failed for event ${failure.eventKey} (session ${failure.sessionId})`,
+    { cause: failure.error }
+  );
+}
+
+// src/integrations/linear/constants.ts
+var DEFAULT_STATUS_MAPPING = {
+  active: "active",
+  waiting: "waiting",
+  canceled: "canceled",
+  completed: "completed",
+  errored: "errored"
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DEFAULT_STATUS_MAPPING,
+  buildLinearAuthorizationHeader,
+  completeLinearSession,
+  createInProcessLinearBridgeDispatcher,
+  createInlineLinearBridgeDispatcher,
+  createLinearBridgeRuntime,
+  createLinearClient,
+  createLinearTools,
+  createLinearWebhookHandler,
+  createSqliteSessionRoomStore,
+  dedupeHandles,
+  handleAgentSessionEvent,
+  isLinearApiKey,
+  postAction,
+  postElicitation,
+  postError,
+  postResponse,
+  postThought,
+  stripHandlePrefix,
+  updatePlan
+});