@mastra/factory 0.2.2-alpha.1 → 0.2.2-alpha.2

package/dist/integrations/platform/linear/integration.js

@@ -1,1335 +1,483 @@
-// src/integrations/platform/linear/integration.ts
-import { registerApiRoute as registerApiRoute2 } from "@mastra/core/server";
-
-// src/integrations/linear/agent-tools.ts
-import { createTool } from "@mastra/core/tools";
-import { z } from "zod";
-
-// src/integrations/linear/routes.ts
+import { PlatformApiClient, PlatformApiError, logPlatformInfo, logPlatformWarn, platformApiClientConfigFromEnv } from "../api-client.js";
+import { buildLinearRoutes } from "../../linear/routes.js";
+import { attachLinearRules } from "../../linear/rules.js";
+import { buildLinearAgentTools } from "../../linear/agent-tools.js";
 import { registerApiRoute } from "@mastra/core/server";
-var UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+//#region src/integrations/platform/linear/integration.ts
+const API_PREFIX = "/v1/server/linear";
+const PAGE_SIZE = 30;
+const MAX_REFERENCE_PAGES = 20;
+const MAX_COMMENT_PAGES = 20;
+const PLATFORM_MANAGED_CONNECTION_TOKEN = "platform-managed";
 function loose(c) {
-  return c;
-}
-async function resolveOrgTenant(c, auth) {
-  await auth.ensureUser(c);
-  const tenant = auth.tenant(c);
-  if (!tenant) return { response: c.json({ error: "unauthorized" }, 401) };
-  if (!tenant.orgId) {
-    return {
-      response: c.json(
-        {
-          error: "organization_required",
-          message: "Linear intake requires an organization. Personal accounts cannot connect Linear."
-        },
-        403
-      )
-    };
-  }
-  return { tenant: { orgId: tenant.orgId, userId: tenant.userId } };
-}
-function parseAfterCursor(raw) {
-  if (raw === void 0 || raw === "") return void 0;
-  if (raw.length > 512 || !/^[\w+/=.:-]+$/.test(raw)) return null;
-  return raw;
-}
-function linearFetchError(c, err) {
-  if (err instanceof LinearReauthRequiredError || err.status === 401) {
-    return c.json({ error: "linear_reauth_required", message: new LinearReauthRequiredError().message }, 409);
-  }
-  return c.json({ error: "linear_fetch_failed", message: err instanceof Error ? err.message : String(err) }, 502);
-}
-function buildLinearRoutes(options) {
-  const routes = [];
-  const { linear, auth, stateSigner, intake } = options;
-  const enabled = Boolean(linear) && auth.enabled();
-  const diagnostics = () => ({
-    linearAppConfigured: Boolean(linear),
-    factoryAuthEnabled: auth.enabled(),
-    appDbConfigured: true
-  });
-  routes.push(
-    registerApiRoute("/web/linear/status", {
-      method: "GET",
-      requiresAuth: false,
-      handler: async (c) => {
-        if (!enabled || !linear || !stateSigner) {
-          return c.json({
-            enabled: false,
-            connected: false,
-            workspace: null,
-            reason: "missing_config",
-            diagnostics: diagnostics()
-          });
-        }
-        await auth.ensureUser(loose(c));
-        const tenant = auth.tenant(loose(c));
-        if (!tenant) return c.json({ error: "unauthorized", reason: "auth_required" }, 401);
-        if (!tenant.orgId) {
-          return c.json({
-            enabled: true,
-            organizationRequired: true,
-            connected: false,
-            workspace: null,
-            reason: "organization_required",
-            diagnostics: diagnostics()
-          });
-        }
-        const connection = await linear.loadConnection(tenant.orgId);
-        return c.json({
-          enabled: true,
-          connected: Boolean(connection),
-          workspace: connection ? { name: connection.workspaceName, urlKey: connection.workspaceUrlKey } : null,
-          reason: connection ? "ready" : "not_connected",
-          diagnostics: diagnostics()
-        });
-      }
-    })
-  );
-  if (!enabled || !linear || !stateSigner || !intake) {
-    return routes;
-  }
-  const redirectUri = options.redirectUri ?? `${(options.baseUrl ?? "").replace(/\/$/, "")}/auth/linear/callback`;
-  routes.push(
-    registerApiRoute("/auth/linear/connect", {
-      method: "GET",
-      requiresAuth: false,
-      handler: async (c) => {
-        const resolved = await resolveOrgTenant(loose(c), auth);
-        if ("response" in resolved) return resolved.response;
-        const state = stateSigner.sign(resolved.tenant.orgId, resolved.tenant.userId);
-        return c.redirect(linear.buildAuthorizeUrl(state, redirectUri));
-      }
-    })
-  );
-  routes.push(
-    registerApiRoute("/auth/linear/callback", {
-      method: "GET",
-      requiresAuth: false,
-      handler: async (c) => {
-        const resolved = await resolveOrgTenant(loose(c), auth);
-        if ("response" in resolved) return resolved.response;
-        const { orgId, userId } = resolved.tenant;
-        const stateTenant = stateSigner.verify(c.req.query("state"));
-        if (!stateTenant || stateTenant.userId !== userId || stateTenant.orgId !== orgId) {
-          console.warn("[Linear] OAuth callback rejected: state/tenant mismatch.");
-          return c.redirect("/?linear=error");
-        }
-        const code = c.req.query("code");
-        if (!code) {
-          return c.redirect("/?linear=error");
-        }
-        try {
-          const tokens = await linear.exchangeOAuthCode(code, redirectUri);
-          const workspace = await linear.fetchWorkspace(tokens.accessToken);
-          await linear.upsertConnection({
-            orgId,
-            userId,
-            accessToken: tokens.accessToken,
-            refreshToken: tokens.refreshToken,
-            expiresAt: tokens.expiresAt,
-            scope: tokens.scope,
-            workspaceName: workspace.name,
-            workspaceUrlKey: workspace.urlKey
-          });
-        } catch (error) {
-          console.warn(`[Linear] OAuth callback failed to persist connection for org ${orgId}.`, error);
-          return c.redirect("/?linear=error");
-        }
-        return c.redirect("/?linear=connected");
-      }
-    })
-  );
-  routes.push(
-    registerApiRoute("/web/linear/projects", {
-      method: "GET",
-      requiresAuth: false,
-      handler: async (c) => {
-        const resolved = await resolveOrgTenant(loose(c), auth);
-        if ("response" in resolved) return resolved.response;
-        const connection = await linear.loadConnection(resolved.tenant.orgId);
-        if (!connection) {
-          return c.json({ error: "linear_not_connected", message: "Connect Linear to list Linear projects." }, 409);
-        }
-        try {
-          const accessToken = await linear.getFreshAccessToken(connection);
-          const projects = await linear.listProjects(accessToken);
-          return c.json({ projects });
-        } catch (err) {
-          return linearFetchError(loose(c), err);
-        }
-      }
-    })
-  );
-  routes.push(
-    registerApiRoute("/web/linear/issues", {
-      method: "GET",
-      requiresAuth: false,
-      handler: async (c) => {
-        const resolved = await resolveOrgTenant(loose(c), auth);
-        if ("response" in resolved) return resolved.response;
-        const after = parseAfterCursor(c.req.query("after"));
-        if (after === null) return c.json({ error: "invalid_cursor" }, 400);
-        const factoryProjectId = c.req.query("factoryProjectId");
-        if (factoryProjectId && !UUID_RE.test(factoryProjectId)) {
-          return c.json({ error: "invalid_factory_project_id" }, 400);
-        }
-        const connection = await linear.loadConnection(resolved.tenant.orgId);
-        if (!connection) {
-          return c.json({ error: "linear_not_connected", message: "Connect Linear to see intake issues." }, 409);
-        }
-        await intake.ensureReady();
-        const config = await intake.getConfig({
-          orgId: resolved.tenant.orgId,
-          userId: resolved.tenant.userId,
-          integrationIds: ["linear"]
-        });
-        const selection = config.linear;
-        if (!selection.enabled) {
-          return c.json({ error: "linear_intake_disabled", message: "Linear intake is turned off in Settings." }, 404);
-        }
-        const projectIds = selection.sourceIds ?? [];
-        if (projectIds.length === 0) {
-          return c.json({ issues: [], nextCursor: null });
-        }
-        try {
-          const accessToken = await linear.getFreshAccessToken(connection);
-          const { issues, nextCursor } = await linear.intake.listIssues({
-            connection: { type: "oauth", accessToken },
-            sourceIds: projectIds,
-            cursor: after
-          });
-          const issuePayload = issues.map((issue) => ({
-            id: issue.id,
-            identifier: issue.identifier,
-            title: issue.title,
-            url: issue.url,
-            state: issue.state ?? "",
-            stateType: issue.stateType ?? "",
-            priorityLabel: issue.priority ?? "",
-            assignee: issue.assignee,
-            team: issue.source,
-            labels: issue.labels,
-            createdAt: issue.createdAt,
-            updatedAt: issue.updatedAt
-          }));
-          if (factoryProjectId && options.ingestFactoryIssues) {
-            await options.ingestFactoryIssues({
-              orgId: resolved.tenant.orgId,
-              userId: resolved.tenant.userId,
-              factoryProjectId,
-              issues: issuePayload
-            });
-          }
-          return c.json({ issues: issuePayload, nextCursor });
-        } catch (err) {
-          return linearFetchError(loose(c), err);
-        }
-      }
-    })
-  );
-  return routes;
-}
-
-// src/rules/resolve.ts
-function resolveFactoryLinearRule(rules, event) {
-  return rules.linear[event]?.onEvent;
-}
-
-// src/rules/types.ts
-var FACTORY_RULE_STAGES = ["intake", "triage", "planning", "execute", "review", "done", "canceled"];
-var FACTORY_RULE_BOARDS = ["work", "review"];
-
-// src/rules/validation.ts
-var MAX_FACTORY_RULE_CAUSAL_DEPTH = 8;
-var MAX_IDEMPOTENCY_KEY_LENGTH = 256;
-var MAX_REASON_LENGTH = 512;
-var MAX_TITLE_LENGTH = 512;
-var MAX_MESSAGE_LENGTH = 8192;
-var MAX_ARGUMENTS_LENGTH = 4096;
-var MAX_ROLE_LENGTH = 32;
-var MAX_SKILL_NAME_LENGTH = 128;
-var MAX_SOURCE_KEY_LENGTH = 256;
-var MAX_URL_LENGTH = 2048;
-var MAX_METADATA_JSON_LENGTH = 16384;
-var MAX_JSON_DEPTH = 8;
-var MAX_JSON_COLLECTION_SIZE = 100;
-var IDENTIFIER_RE = /^[a-z0-9][a-z0-9_-]*$/i;
-var SKILL_NAME_RE = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
-var SENSITIVE_KEY_RE = /(?:authorization|cookie|credential|password|secret|token)/i;
-var WORK_ITEM_SOURCES = ["github-issue", "github-pr", "linear-issue", "manual"];
-var REJECTION_CODES = [
-  "forbidden",
-  "invalid_transition",
-  "missing_binding",
-  "stale",
-  "timeout",
-  "rule_error",
-  "causal_depth_exceeded",
-  "repeated_transition"
-];
-var FactoryRuleValidationError = class extends Error {
-  code = "invalid_factory_rule";
-  constructor(message) {
-    super(message);
-    this.name = "FactoryRuleValidationError";
-  }
-};
-function isPlainObject(value) {
-  if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
-  const prototype = Object.getPrototypeOf(value);
-  return prototype === Object.prototype || prototype === null;
-}
-function assertExactKeys(value, keys, label) {
-  const allowed = new Set(keys);
-  if (Object.keys(value).some((key) => !allowed.has(key))) {
-    throw new FactoryRuleValidationError(`${label} contains an unsupported field.`);
-  }
-}
-function boundedString(value, label, max, pattern) {
-  if (typeof value !== "string") throw new FactoryRuleValidationError(`${label} must be a string.`);
-  const normalized = value.trim();
-  if (normalized.length === 0 || normalized.length > max || pattern && !pattern.test(normalized)) {
-    throw new FactoryRuleValidationError(`${label} is invalid.`);
-  }
-  return normalized;
-}
-function optionalBoundedString(value, label, max) {
-  if (value === void 0) return void 0;
-  return boundedString(value, label, max);
-}
-function enumValue(value, allowed, label) {
-  if (typeof value !== "string" || !allowed.includes(value)) {
-    throw new FactoryRuleValidationError(`${label} is invalid.`);
-  }
-  return value;
-}
-function normalizeFactoryRuleJsonValue(value, depth = 0, seen = /* @__PURE__ */ new Set()) {
-  if (value === null || typeof value === "boolean" || typeof value === "string") return value;
-  if (typeof value === "number") {
-    if (!Number.isFinite(value)) throw new FactoryRuleValidationError("Rule metadata must contain finite numbers.");
-    return value;
-  }
-  if (depth >= MAX_JSON_DEPTH || typeof value !== "object" && !Array.isArray(value)) {
-    throw new FactoryRuleValidationError("Rule metadata is not bounded JSON.");
-  }
-  if (seen.has(value)) throw new FactoryRuleValidationError("Rule metadata must not contain cycles.");
-  seen.add(value);
-  try {
-    if (Array.isArray(value)) {
-      if (value.length > MAX_JSON_COLLECTION_SIZE) {
-        throw new FactoryRuleValidationError("Rule metadata contains too many entries.");
-      }
-      return value.map((entry) => normalizeFactoryRuleJsonValue(entry, depth + 1, seen));
-    }
-    if (!isPlainObject(value)) throw new FactoryRuleValidationError("Rule metadata must use plain objects.");
-    const entries = Object.entries(value);
-    if (entries.length > MAX_JSON_COLLECTION_SIZE) {
-      throw new FactoryRuleValidationError("Rule metadata contains too many fields.");
-    }
-    const sanitized = {};
-    for (const [key, entry] of entries) {
-      const normalizedKey = boundedString(key, "Rule metadata key", 128, IDENTIFIER_RE);
-      sanitized[normalizedKey] = SENSITIVE_KEY_RE.test(normalizedKey) ? "[REDACTED]" : normalizeFactoryRuleJsonValue(entry, depth + 1, seen);
-    }
-    return sanitized;
-  } finally {
-    seen.delete(value);
-  }
-}
-function sanitizeMetadata(value) {
-  if (value === void 0) return void 0;
-  const sanitized = normalizeFactoryRuleJsonValue(value);
-  if (!isPlainObject(sanitized)) throw new FactoryRuleValidationError("Rule metadata must be an object.");
-  if (JSON.stringify(sanitized).length > MAX_METADATA_JSON_LENGTH) {
-    throw new FactoryRuleValidationError("Rule metadata is too large.");
-  }
-  return sanitized;
-}
-function commonCommitFields(value) {
-  return {
-    idempotencyKey: boundedString(value.idempotencyKey, "Factory decision idempotencyKey", MAX_IDEMPOTENCY_KEY_LENGTH)
-  };
-}
-function validateFactoryRuleDecision(value, causalDepth = 0) {
-  if (causalDepth > MAX_FACTORY_RULE_CAUSAL_DEPTH) {
-    throw new FactoryRuleValidationError("Factory rule causal depth exceeded.");
-  }
-  if (!isPlainObject(value)) throw new FactoryRuleValidationError("Factory rule decision must be an object.");
-  const type = value.type;
-  if (typeof type !== "string") throw new FactoryRuleValidationError("Factory rule decision type is required.");
-  switch (type) {
-    case "reject": {
-      assertExactKeys(value, ["type", "code", "reason"], "Factory reject decision");
-      return {
-        type,
-        code: enumValue(value.code, REJECTION_CODES, "Factory rejection code"),
-        reason: boundedString(value.reason, "Factory rejection reason", MAX_REASON_LENGTH)
-      };
-    }
-    case "transition": {
-      assertExactKeys(value, ["type", "idempotencyKey", "board", "stage"], "Factory transition decision");
-      return {
-        type,
-        ...commonCommitFields(value),
-        board: enumValue(value.board, FACTORY_RULE_BOARDS, "Factory transition board"),
-        stage: enumValue(value.stage, FACTORY_RULE_STAGES, "Factory transition stage")
-      };
-    }
-    case "upsertLinkedWorkItem": {
-      assertExactKeys(
-        value,
-        ["type", "idempotencyKey", "board", "source", "sourceKey", "title", "url", "stage", "metadata"],
-        "Factory linked work item decision"
-      );
-      const url = value.url;
-      if (url !== null && (typeof url !== "string" || url.length > MAX_URL_LENGTH || !/^https?:\/\//.test(url))) {
-        throw new FactoryRuleValidationError("Factory linked work item URL is invalid.");
-      }
-      const metadata = sanitizeMetadata(value.metadata);
-      return {
-        type,
-        ...commonCommitFields(value),
-        board: enumValue(value.board, FACTORY_RULE_BOARDS, "Factory linked work item board"),
-        source: enumValue(value.source, WORK_ITEM_SOURCES, "Factory linked work item source"),
-        sourceKey: boundedString(value.sourceKey, "Factory linked work item sourceKey", MAX_SOURCE_KEY_LENGTH),
-        title: boundedString(value.title, "Factory linked work item title", MAX_TITLE_LENGTH),
-        url,
-        stage: enumValue(value.stage, FACTORY_RULE_STAGES, "Factory linked work item stage"),
-        ...metadata ? { metadata } : {}
-      };
-    }
-    case "invokeSkill": {
-      assertExactKeys(
-        value,
-        ["type", "idempotencyKey", "role", "skillName", "arguments", "precedingMessage"],
-        "Factory invoke skill decision"
-      );
-      const args = optionalBoundedString(value.arguments, "Factory skill arguments", MAX_ARGUMENTS_LENGTH);
-      const precedingMessage = optionalBoundedString(
-        value.precedingMessage,
-        "Factory skill preceding message",
-        MAX_MESSAGE_LENGTH
-      );
-      return {
-        type,
-        ...commonCommitFields(value),
-        role: boundedString(value.role, "Factory skill role", MAX_ROLE_LENGTH, IDENTIFIER_RE),
-        skillName: boundedString(value.skillName, "Factory skill name", MAX_SKILL_NAME_LENGTH, SKILL_NAME_RE),
-        ...args ? { arguments: args } : {},
-        ...precedingMessage ? { precedingMessage } : {}
-      };
-    }
-    case "sendMessage": {
-      assertExactKeys(
-        value,
-        ["type", "idempotencyKey", "role", "message", "priority", "idleBehavior", "prepareBinding"],
-        "Factory send message decision"
-      );
-      const priority = value.priority === void 0 ? void 0 : enumValue(value.priority, ["medium", "high", "urgent"], "Factory message priority");
-      const idleBehavior = value.idleBehavior === void 0 ? void 0 : enumValue(value.idleBehavior, ["persist", "wake"], "Factory message idle behavior");
-      if (value.prepareBinding !== void 0 && typeof value.prepareBinding !== "boolean") {
-        throw new FactoryRuleValidationError("Factory message prepareBinding must be a boolean.");
-      }
-      return {
-        type,
-        ...commonCommitFields(value),
-        role: boundedString(value.role, "Factory message role", MAX_ROLE_LENGTH, IDENTIFIER_RE),
-        message: boundedString(value.message, "Factory message", MAX_MESSAGE_LENGTH),
-        ...priority ? { priority } : {},
-        ...idleBehavior ? { idleBehavior } : {},
-        ...value.prepareBinding === true ? { prepareBinding: true } : {}
-      };
-    }
-    case "notify": {
-      assertExactKeys(value, ["type", "idempotencyKey", "title", "body", "level"], "Factory notify decision");
-      const body = optionalBoundedString(value.body, "Factory notification body", MAX_MESSAGE_LENGTH);
-      const level = value.level === void 0 ? void 0 : enumValue(value.level, ["info", "warning", "error"], "Factory notification level");
-      return {
-        type,
-        ...commonCommitFields(value),
-        title: boundedString(value.title, "Factory notification title", MAX_TITLE_LENGTH),
-        ...body ? { body } : {},
-        ...level ? { level } : {}
-      };
-    }
-    default:
-      throw new FactoryRuleValidationError("Factory rule decision type is unsupported.");
-  }
-}
-function validateFactoryRuleDecisions(values, causalDepth = 0) {
-  if (values.length > MAX_JSON_COLLECTION_SIZE) {
-    throw new FactoryRuleValidationError("Factory rule produced too many decisions.");
-  }
-  const decisions = [];
-  for (const value of values) {
-    const decision = validateFactoryRuleDecision(value, causalDepth);
-    if (decision.type === "reject") {
-      throw new FactoryRuleValidationError("A rejection cannot be persisted with commit decisions.");
-    }
-    decisions.push(decision);
-  }
-  const keys = decisions.map((decision) => decision.idempotencyKey);
-  if (new Set(keys).size !== keys.length) {
-    throw new FactoryRuleValidationError("Factory decisions require unique idempotency keys.");
-  }
-  return decisions;
-}
-
-// src/integrations/linear/rules.ts
-var RULE_TIMEOUT_MS = 5e3;
-async function withRuleTimeout(promise) {
-  let timeout;
-  try {
-    return await Promise.race([
-      promise,
-      new Promise((_, reject) => {
-        timeout = setTimeout(() => reject(new Error("FACTORY_RULE_TIMEOUT")), RULE_TIMEOUT_MS);
-      })
-    ]);
-  } finally {
-    if (timeout) clearTimeout(timeout);
-  }
-}
-var LinearRules = class {
-  constructor(options) {
-    this.options = options;
-  }
-  options;
-  async ingest(input) {
-    const project = await this.options.projects.get({ orgId: input.orgId, id: input.factoryProjectId });
-    if (!project) return { status: "missing", ingested: 0 };
-    const items = await this.options.storage.list({ orgId: input.orgId, factoryProjectId: input.factoryProjectId });
-    const itemsBySourceKey = new Map(items.map((item) => [item.externalSource?.externalId, item]));
-    const statuses = [];
-    for (const issue of input.issues) {
-      statuses.push(await this.#ingestIssue(input, issue, itemsBySourceKey.get(`linear:${issue.identifier}`)));
-    }
-    if (statuses.some((status) => status === "committed")) return { status: "committed", ingested: statuses.length };
-    if (statuses.some((status) => status === "replayed")) return { status: "replayed", ingested: statuses.length };
-    return { status: "missing", ingested: statuses.length };
-  }
-  async #ingestIssue(input, issue, relatedItem) {
-    const ingressId = `linear:${issue.id}:${issue.updatedAt}`;
-    const actor = { type: "human", id: input.userId };
-    const context = {
-      tenant: { orgId: input.orgId, projectId: input.factoryProjectId },
-      actor,
-      ingress: { type: "linear", id: ingressId },
-      cause: "linear.issueObserved",
-      causalChain: [],
-      ruleSetVersion: this.options.rules.version,
-      ...relatedItem ? {
-        item: {
-          id: relatedItem.id,
-          source: "linear-issue",
-          sourceKey: relatedItem.externalSource?.externalId ?? null,
-          parentWorkItemId: relatedItem.parentWorkItemId,
-          title: relatedItem.title,
-          url: relatedItem.externalSource?.url ?? null,
-          stages: relatedItem.stages
-        },
-        board: "work",
-        itemRevision: relatedItem.revision
-      } : {},
-      event: "issueObserved",
-      issue
-    };
-    const rule = resolveFactoryLinearRule(this.options.rules, context.event);
-    let decision;
-    let decisions = [];
-    let outcome = { status: "accepted" };
-    try {
-      decision = rule ? await withRuleTimeout(Promise.resolve(rule(Object.freeze(context)))) : void 0;
-      if (decision?.type === "reject") {
-        outcome = { status: "rejected", code: decision.code, reason: decision.reason };
-      } else if (decision) {
-        decisions = validateFactoryRuleDecisions([decision]).map((entry) => ({ ...entry }));
-      }
-    } catch (error) {
-      const timedOut = error instanceof Error && error.message === "FACTORY_RULE_TIMEOUT";
-      outcome = {
-        status: "rejected",
-        code: timedOut ? "timeout" : "rule_error",
-        reason: timedOut ? "Factory rule evaluation timed out." : error instanceof Error ? error.message.slice(0, 2e3) : "Factory Linear rule failed."
-      };
-    }
-    const committed = await this.options.storage.commitRuleEvaluation({
-      orgId: input.orgId,
-      factoryProjectId: input.factoryProjectId,
-      workItemId: relatedItem?.id ?? null,
-      ingress: { identity: ingressId, triggerType: "linear.issueObserved" },
-      ruleSetVersion: this.options.rules.version,
-      expectedRevision: relatedItem?.revision ?? null,
-      actor,
-      outcome,
-      decisions,
-      causalChain: [],
-      now: /* @__PURE__ */ new Date()
-    });
-    return committed.status;
-  }
-};
-function attachLinearRules(context) {
-  if (!context.rules) return void 0;
-  const rules = new LinearRules({
-    projects: context.storage.projects,
-    storage: context.rules.workItems,
-    rules: context.rules.config
-  });
-  return (input) => rules.ingest(input);
-}
-
-// src/integrations/linear/integration.ts
-var LinearReauthRequiredError = class extends Error {
-  constructor() {
-    super("Linear authorization expired. Reconnect Linear to keep syncing intake issues.");
-  }
-};
-
-// src/integrations/linear/agent-tools.ts
-function createLinearGetIssueTool(linear, orgId) {
-  return createTool({
-    id: "linear_get_issue",
-    description: "Fetch a Linear issue's full details \u2014 title, description, state, assignee, labels, priority, and discussion comments. Use this whenever you're working on a Linear issue (e.g. ENG-123) to get its complete context.",
-    inputSchema: z.object({
-      issue: z.string().min(1).describe('The Linear issue identifier (e.g. "ENG-123") or issue UUID.')
-    }),
-    execute: async ({ issue }) => {
-      const connection = await linear.loadConnection(orgId);
-      if (!connection) {
-        return { error: "Linear is not connected for this repository. Connect Linear in Settings to fetch issues." };
-      }
-      try {
-        const accessToken = await linear.getFreshAccessToken(connection);
-        const detail = await linear.intake.getIssue({
-          connection: { type: "oauth", accessToken },
-          issueId: issue.trim()
-        });
-        if (!detail) {
-          return { error: `Linear issue "${issue}" was not found in this workspace.` };
-        }
-        return detail;
-      } catch (err) {
-        if (err instanceof LinearReauthRequiredError) {
-          return { error: err.message };
-        }
-        return { error: `Failed to fetch Linear issue: ${err instanceof Error ? err.message : String(err)}` };
-      }
-    }
-  });
-}
-function createLinearCommentTool(linear, orgId) {
-  return createTool({
-    id: "linear_create_comment",
-    description: "Post a comment on a Linear issue (e.g. to report investigation findings, link a PR, or ask a clarifying question). The comment is posted as the connected Linear integration, so make clear it comes from the agent.",
-    inputSchema: z.object({
-      issue: z.string().min(1).describe('The Linear issue identifier (e.g. "ENG-123") or issue UUID.'),
-      body: z.string().min(1).describe("The comment body, as Linear-flavored markdown.")
-    }),
-    execute: async ({ issue, body }) => {
-      const connection = await linear.loadConnection(orgId);
-      if (!connection) {
-        return { error: "Linear is not connected for this repository. Connect Linear in Settings to post comments." };
-      }
-      if (!linear.canPostComments(connection)) {
-        return {
-          error: "The Linear connection does not have comment permissions. Reconnect Linear in Settings to grant them."
-        };
-      }
-      try {
-        const accessToken = await linear.getFreshAccessToken(connection);
-        const comment = await linear.intake.createComment({
-          connection: { type: "oauth", accessToken },
-          issueId: issue.trim(),
-          body
-        });
-        if (!comment) {
-          return { error: `Linear issue "${issue}" was not found in this workspace.` };
-        }
-        return { posted: true, url: comment.url };
-      } catch (err) {
-        if (err instanceof LinearReauthRequiredError) {
-          return { error: err.message };
-        }
-        return { error: `Failed to post Linear comment: ${err instanceof Error ? err.message : String(err)}` };
-      }
-    }
-  });
-}
-async function buildLinearAgentTools({
-  requestContext,
-  linear
-}) {
-  if (!linear.authEnabled) return {};
-  const ctx = requestContext.get("controller");
-  const resourceId = ctx?.resourceId;
-  if (!resourceId) return {};
-  const orgId = await linear.resolveOrgId(resourceId);
-  if (!orgId) return {};
-  const check = await linear.checkConnection(orgId);
-  if (!check.connected) return {};
-  return {
-    linear_get_issue: createLinearGetIssueTool(linear, orgId),
-    // Only offered when the granted OAuth scope allows posting comments —
-    // connections made before `comments:create` was requested are read-only
-    // until the org reconnects Linear.
-    ...check.canComment ? { linear_create_comment: createLinearCommentTool(linear, orgId) } : {}
-  };
-}
-
-// src/integrations/platform/api-client.ts
-function platformApiClientConfigFromEnv() {
-  const sharedApiUrl = process.env.MASTRA_SHARED_API_URL?.trim() || "https://platform.mastra.ai/v1";
-  const accessToken = process.env.MASTRA_PLATFORM_SECRET_KEY?.trim();
-  if (!accessToken) {
-    throw new Error("Platform integration: missing required environment variable MASTRA_PLATFORM_SECRET_KEY.");
-  }
-  return { baseUrl: normalizeSharedApiUrl(sharedApiUrl), accessToken };
-}
-function normalizeSharedApiUrl(sharedApiUrl) {
-  return sharedApiUrl.replace(/\/+$/, "").replace(/\/v1$/, "");
-}
-var PlatformApiError = class extends Error {
-  status;
-  retryAfterSeconds;
-  constructor(message, status, retryAfterSeconds = null) {
-    super(message);
-    this.name = "PlatformApiError";
-    this.status = status;
-    this.retryAfterSeconds = retryAfterSeconds;
-  }
-};
-var PlatformApiClient = class {
-  #baseUrl;
-  #accessToken;
-  #fetch;
-  constructor(config) {
-    const missing = ["baseUrl", "accessToken"].filter((field) => !config[field]);
-    if (missing.length > 0) {
-      throw new Error(`Platform integration: missing required config field(s): ${missing.join(", ")}.`);
-    }
-    this.#baseUrl = config.baseUrl.replace(/\/+$/, "");
-    this.#accessToken = config.accessToken;
-    this.#fetch = config.fetchImpl ?? globalThis.fetch;
-  }
-  async request(method, path, body, options) {
-    const response = await this.#send(method, path, body, options);
-    if (!response.ok) {
-      const message = redact(await extractError(response), this.#accessToken);
-      const retryAfterSeconds = parseRetryAfter(response.headers.get("retry-after"));
-      logPlatformError("Platform API request failed", {
-        method,
-        path,
-        status: response.status,
-        retryAfterSeconds,
-        message
-      });
-      throw new PlatformApiError(message, response.status, retryAfterSeconds);
-    }
-    if (response.status === 204) return void 0;
-    return await response.json();
-  }
-  async requestRedirect(method, path, options) {
-    const response = await this.#send(method, path, void 0, options, "manual");
-    if (response.status >= 300 && response.status < 400) {
-      const location = response.headers.get("location");
-      if (location) return location;
-    }
-    if (!response.ok) {
-      const message = redact(await extractError(response), this.#accessToken);
-      const retryAfterSeconds = parseRetryAfter(response.headers.get("retry-after"));
-      logPlatformError("Platform API redirect request failed", {
-        method,
-        path,
-        status: response.status,
-        retryAfterSeconds,
-        message
-      });
-      throw new PlatformApiError(message, response.status, retryAfterSeconds);
-    }
-    logPlatformError("Platform API request did not return a redirect", { method, path, status: response.status });
-    throw new PlatformApiError("Platform API request did not return a redirect.", response.status);
-  }
-  async #send(method, path, body, options, redirect) {
-    const headers = {
-      accept: "application/json",
-      authorization: `Bearer ${this.#accessToken}`
-    };
-    if (options?.actingUserId) {
-      headers["x-acting-user-id"] = options.actingUserId;
-    }
-    const timeoutSignal = AbortSignal.timeout(15e3);
-    const init = {
-      method,
-      headers,
-      redirect,
-      signal: options?.signal ? AbortSignal.any([options.signal, timeoutSignal]) : timeoutSignal
-    };
-    if (body !== void 0) {
-      headers["content-type"] = "application/json";
-      init.body = JSON.stringify(body);
-    }
-    try {
-      return await this.#fetch(`${this.#baseUrl}${path}`, init);
-    } catch (error) {
-      if (error instanceof Error && error.message.includes(this.#accessToken)) {
-        const redacted = new Error(redact(error.message, this.#accessToken));
-        redacted.name = error.name;
-        logPlatformError("Platform API transport error", {
-          method,
-          path,
-          name: redacted.name,
-          message: redacted.message
-        });
-        throw redacted;
-      }
-      logPlatformError("Platform API transport error", {
-        method,
-        path,
-        name: error instanceof Error ? error.name : void 0,
-        message: error instanceof Error ? error.message : String(error)
-      });
-      throw error;
-    }
-  }
-};
-async function extractError(response) {
-  try {
-    const data = await response.clone().json();
-    for (const field of ["detail", "error", "title"]) {
-      if (typeof data[field] === "string" && data[field]) return data[field];
-    }
-  } catch {
-  }
-  return `Platform API request failed (${response.status})`;
-}
-function redact(message, accessToken) {
-  return message.split(accessToken).join("[REDACTED]");
-}
-function logPlatformInfo(message, fields) {
-  writePlatformLog("info", message, fields);
-}
-function logPlatformWarn(message, fields) {
-  writePlatformLog("warn", message, fields);
-}
-function logPlatformError(message, fields) {
-  writePlatformLog("error", message, fields);
-}
-function writePlatformLog(level, message, fields) {
-  const metadata = fields ? ` ${JSON.stringify(stripUndefined(fields))}` : "";
-  process.stderr.write(`[Mastra Factory] ${level.toUpperCase()} ${message}${metadata}
-`);
-}
-function stripUndefined(fields) {
-  return Object.fromEntries(Object.entries(fields).filter(([, value]) => value !== void 0));
-}
-function parseRetryAfter(value) {
-  if (!value) return null;
-  const seconds = Number.parseInt(value, 10);
-  return Number.isSafeInteger(seconds) && seconds >= 0 ? seconds : null;
-}
-
-// src/integrations/platform/linear/integration.ts
-var API_PREFIX = "/v1/server/linear";
-var PAGE_SIZE = 30;
-var MAX_REFERENCE_PAGES = 20;
-var MAX_COMMENT_PAGES = 20;
-var PLATFORM_MANAGED_CONNECTION_TOKEN = "platform-managed";
-function loose2(c) {
-  return c;
+	return c;
 }
 function routeBaseUrl(ctx, requestUrl) {
-  return (ctx.baseUrl || new URL(requestUrl).origin).replace(/\/+$/, "");
+	return (ctx.baseUrl || new URL(requestUrl).origin).replace(/\/+$/, "");
 }
 var PlatformLinearIntegration = class {
-  id = "linear";
-  #client;
-  #endpointHost;
-  #projects;
-  #auth;
-  /**
-   * Per-instance workflow-state cache keyed by `${workspaceId}:${teamId}`. Scoped to the process
-   * lifetime; not shared across requests intentionally to keep failure modes simple (stale states
-   * clear on process restart). Populated lazily on first `updateIssue` per team.
-   */
-  #workflowStatesByTeam = /* @__PURE__ */ new Map();
-  intake = {
-    resolveIntakeDispatch: (input) => this.#resolveIntakeDispatch(input),
-    listSources: async () => {
-      const sources = await this.#listProjectSources();
-      return sources.map(({ workspace, project }) => ({
-        id: encodeSourceId(workspace.linearWorkspaceId, project.id),
-        name: project.name,
-        type: "project",
-        metadata: {
-          workspaceId: workspace.linearWorkspaceId,
-          workspaceName: workspace.linearWorkspaceName,
-          workspaceUrlKey: workspace.urlKey,
-          state: project.state,
-          teams: project.teams
-        }
-      }));
-    },
-    listItems: async ({ sourceIds, cursor }) => {
-      const result = await this.#listIssues(sourceIds, cursor);
-      return {
-        items: result.issues.map(({ issue, source }) => ({
-          source: { type: "issue", externalId: issue.id, url: issue.url },
-          sourceId: encodeSourceId(source.workspace.linearWorkspaceId, source.project.id),
-          title: issue.title,
-          status: issue.state.name,
-          labels: issue.labels.map((label) => label.name),
-          assignee: issue.assignee?.displayName ?? issue.assignee?.name ?? null,
-          createdAt: issue.createdAt,
-          updatedAt: issue.updatedAt,
-          metadata: {
-            identifier: issue.identifier,
-            workspaceId: source.workspace.linearWorkspaceId,
-            workspaceName: source.workspace.linearWorkspaceName,
-            projectId: source.project.id,
-            projectName: source.project.name,
-            team: issue.team.key,
-            priority: issue.priorityLabel
-          }
-        })),
-        nextCursor: result.nextCursor
-      };
-    },
-    listIssues: async ({ connection, sourceIds, labels, cursor }) => {
-      requireLinearConnection(connection);
-      const result = await this.#listIssues(sourceIds, cursor, labels);
-      return {
-        issues: result.issues.map(({ issue }) => parseIssue(issue)),
-        nextCursor: result.nextCursor
-      };
-    },
-    getIssue: async ({ connection, sourceId, issueId }) => {
-      requireLinearConnection(connection);
-      const located = await this.#findIssue(sourceId, issueId);
-      if (!located) return null;
-      const comments = await this.#loadComments(located.workspaceId, issueId, located.issue.comments);
-      return parseIssueDetail(located.issue, comments);
-    },
-    createComment: async ({ connection, sourceId, issueId, body }) => {
-      requireLinearConnection(connection);
-      const workspaceId = await this.#resolveWorkspaceForIssue(sourceId, issueId);
-      if (!workspaceId) return null;
-      try {
-        const comment = await this.#client.request(
-          "POST",
-          `${API_PREFIX}/workspaces/${encodeURIComponent(workspaceId)}/issues/${encodeURIComponent(issueId)}/comments`,
-          { body }
-        );
-        return { id: comment.id, url: comment.url };
-      } catch (error) {
-        if (isNotFound(error)) return null;
-        throw error;
-      }
-    },
-    updateIssue: async (input) => {
-      requireLinearConnection(input.connection);
-      const located = await this.#findIssue(input.sourceId, input.issueId);
-      if (!located) return null;
-      const { workspaceId, issue } = located;
-      const target = input.state;
-      if (target.kind === "byType" && issue.state.type === target.stateType) {
-        return parseIssue(issue);
-      }
-      if (target.kind === "byName" && issue.state.name.toLowerCase() === target.name.toLowerCase()) {
-        return parseIssue(issue);
-      }
-      let states;
-      try {
-        states = await this.#listWorkflowStates(workspaceId, issue.team.id);
-      } catch (error) {
-        if (isNotFound(error)) {
-          logPlatformWarn("Platform Linear: workflow-states endpoint not available; skipping updateIssue.", {
-            workspaceId,
-            teamId: issue.team.id
-          });
-          return null;
-        }
-        throw error;
-      }
-      let matched;
-      if (target.kind === "byType") {
-        matched = states.slice().sort((a, b) => a.position - b.position).find((s) => s.type === target.stateType);
-      } else {
-        const wanted = target.name.toLowerCase();
-        matched = states.find((s) => s.name.toLowerCase() === wanted);
-      }
-      if (!matched) {
-        logPlatformWarn("Platform Linear: no workflow state matched target; skipping updateIssue.", {
-          workspaceId,
-          teamId: issue.team.id,
-          target
-        });
-        return null;
-      }
-      try {
-        await this.#client.request(
-          "PATCH",
-          `${API_PREFIX}/workspaces/${encodeURIComponent(workspaceId)}/issues/${encodeURIComponent(input.issueId)}`,
-          { stateId: matched.id }
-        );
-      } catch (error) {
-        if (isNotFound(error)) return null;
-        throw error;
-      }
-      const refreshed = await this.#findIssue(input.sourceId, input.issueId);
-      return refreshed ? parseIssue(refreshed.issue) : null;
-    }
-  };
-  constructor() {
-    const config = platformApiClientConfigFromEnv();
-    this.#client = new PlatformApiClient(config);
-    this.#endpointHost = new URL(config.baseUrl).host;
-  }
-  get storage() {
-    const now = /* @__PURE__ */ new Date();
-    return {
-      integrationId: this.id,
-      connections: {
-        get: async (orgId) => ({
-          id: `platform-linear:${orgId}`,
-          orgId,
-          userId: null,
-          data: {
-            accessToken: PLATFORM_MANAGED_CONNECTION_TOKEN,
-            refreshToken: null,
-            expiresAtMs: null,
-            scope: "read,comments:create",
-            workspaceName: null,
-            workspaceUrlKey: null
-          },
-          metadata: {},
-          createdAt: now,
-          updatedAt: now
-        })
-      }
-    };
-  }
-  get projects() {
-    if (!this.#projects) throw new Error("PlatformLinearIntegration projects storage has not been initialized.");
-    return this.#projects;
-  }
-  initialize({ projects, auth }) {
-    this.#projects = projects;
-    this.#auth = auth;
-    logPlatformInfo("Platform Linear integration initialized", { endpointHost: this.#endpointHost });
-  }
-  get authEnabled() {
-    return this.#auth?.enabled() ?? false;
-  }
-  async resolveOrgId(resourceId) {
-    try {
-      const project = await this.projects.getById({ id: resourceId });
-      return project?.orgId ?? null;
-    } catch {
-      return null;
-    }
-  }
-  async loadConnection(orgId) {
-    const workspace = (await this.#listWorkspaces())[0];
-    if (!workspace) return null;
-    const now = /* @__PURE__ */ new Date();
-    return {
-      id: `platform-linear:${orgId}`,
-      orgId,
-      userId: null,
-      accessToken: PLATFORM_MANAGED_CONNECTION_TOKEN,
-      scope: "read,comments:create",
-      refreshToken: null,
-      expiresAt: null,
-      workspaceName: workspace.linearWorkspaceName,
-      workspaceUrlKey: workspace.urlKey,
-      createdAt: now,
-      updatedAt: now
-    };
-  }
-  async getFreshAccessToken(_connection) {
-    return PLATFORM_MANAGED_CONNECTION_TOKEN;
-  }
-  /**
-   * Background-dispatch context: platform-managed connection token when the
-   * org has a connected workspace. Linear work items store the issue UUID
-   * directly as `externalId`.
-   */
-  async #resolveIntakeDispatch({
-    orgId,
-    externalSource
-  }) {
-    if (externalSource.type !== "issue") return null;
-    const connection = await this.loadConnection(orgId);
-    if (!connection) return null;
-    return {
-      connection: { type: "oauth", accessToken: PLATFORM_MANAGED_CONNECTION_TOKEN },
-      issueId: externalSource.externalId
-    };
-  }
-  canPostComments(connection) {
-    const scopes = (connection.scope ?? "").split(/[\s,]+/).filter(Boolean);
-    return scopes.some((scope) => scope === "comments:create" || scope === "write" || scope === "admin");
-  }
-  async checkConnection(orgId) {
-    const connection = await this.loadConnection(orgId);
-    return {
-      connected: connection !== null,
-      canComment: connection !== null && this.canPostComments(connection),
-      checkedAt: Date.now()
-    };
-  }
-  routes(ctx) {
-    return [
-      this.#connectRoute(ctx),
-      ...buildLinearRoutes({
-        auth: ctx.auth,
-        linear: this,
-        stateSigner: ctx.stateSigner,
-        baseUrl: ctx.baseUrl,
-        intake: ctx.storage.intake,
-        ingestFactoryIssues: attachLinearRules(ctx)
-      }).filter((route) => !route.path.startsWith("/auth/linear/"))
-    ];
-  }
-  #connectRoute(ctx) {
-    return registerApiRoute2("/auth/linear/connect", {
-      method: "GET",
-      requiresAuth: false,
-      handler: async (c) => {
-        await ctx.auth.ensureUser(loose2(c));
-        const tenant = ctx.auth.tenant(loose2(c));
-        if (!tenant?.orgId) return c.json({ error: "unauthorized" }, 401);
-        const returnTo = c.req.query("return_to") || "/";
-        const originator = routeBaseUrl(ctx, c.req.url);
-        logPlatformInfo("Starting Platform Linear connect flow", {
-          orgId: tenant.orgId,
-          returnTo,
-          originator
-        });
-        const query = new URLSearchParams({ return_to: returnTo, originator });
-        const location = await this.#client.requestRedirect("GET", `${API_PREFIX}/authorize?${query}`);
-        return c.redirect(location);
-      }
-    });
-  }
-  async agentTools({ requestContext }) {
-    return buildLinearAgentTools({ requestContext, linear: this });
-  }
-  diagnostics() {
-    return { mode: "platform", endpointHost: this.#endpointHost };
-  }
-  async listProjects() {
-    return (await this.#listProjectSources()).map(({ workspace, project }) => ({
-      ...project,
-      id: encodeSourceId(workspace.linearWorkspaceId, project.id),
-      workspaceId: workspace.linearWorkspaceId
-    }));
-  }
-  async #listProjectSources() {
-    const workspaces = await this.#listWorkspaces();
-    const projectGroups = await Promise.all(
-      workspaces.map(async (workspace) => {
-        const projects = [];
-        let after;
-        for (let page = 0; page < MAX_REFERENCE_PAGES; page += 1) {
-          const query = new URLSearchParams({ first: "200" });
-          if (after) query.set("after", after);
-          const result = await this.#client.request(
-            "GET",
-            `${API_PREFIX}/workspaces/${encodeURIComponent(workspace.linearWorkspaceId)}/projects?${query}`
-          );
-          projects.push(...result.projects);
-          if (!result.pageInfo.hasNextPage || !result.pageInfo.endCursor) break;
-          after = result.pageInfo.endCursor;
-        }
-        return projects.map((project) => ({ workspace, project }));
-      })
-    );
-    return projectGroups.flat();
-  }
-  async #listWorkspaces() {
-    const result = await this.#client.request("GET", `${API_PREFIX}/workspaces`);
-    return result.workspaces.filter((workspace) => workspace.connected);
-  }
-  async #listIssues(sourceIds, cursor, labels) {
-    if (sourceIds.length === 0)
-      return { issues: [], nextCursor: null };
-    const sources = await this.#listProjectSources();
-    const sourceMap = new Map(
-      sources.map((source) => [encodeSourceId(source.workspace.linearWorkspaceId, source.project.id), source])
-    );
-    const selected = sourceIds.map((sourceId) => sourceMap.get(sourceId)).filter((source) => !!source);
-    const cursors = decodeCursor(cursor, sourceIds);
-    const normalizedLabels = normalizeLabels(labels);
-    const nextState = {};
-    let hasNextPage = false;
-    const pages = await Promise.all(
-      selected.map(async (source) => {
-        const sourceId = encodeSourceId(source.workspace.linearWorkspaceId, source.project.id);
-        if (cursors[sourceId] === null) {
-          nextState[sourceId] = null;
-          return [];
-        }
-        const query = new URLSearchParams({
-          first: String(PAGE_SIZE),
-          projectIds: source.project.id,
-          stateType: "triage,backlog,unstarted,started",
-          orderBy: "updatedAt"
-        });
-        const after = cursors[sourceId];
-        if (after) query.set("after", after);
-        const result = await this.#client.request(
-          "GET",
-          `${API_PREFIX}/workspaces/${encodeURIComponent(source.workspace.linearWorkspaceId)}/issues?${query}`
-        );
-        const next = result.pageInfo.hasNextPage ? result.pageInfo.endCursor : null;
-        nextState[sourceId] = next;
-        hasNextPage ||= next !== null;
-        return result.issues.filter(
-          (issue) => normalizedLabels.length === 0 || issue.labels.some((label) => normalizedLabels.includes(label.name))
-        ).map((issue) => ({ issue, source }));
-      })
-    );
-    return {
-      issues: pages.flat(),
-      nextCursor: hasNextPage ? encodeCursor(nextState, sourceIds) : null
-    };
-  }
-  async #findIssue(sourceId, issueId) {
-    const workspaceIds = await this.#candidateWorkspaceIds(sourceId);
-    for (const workspaceId of workspaceIds) {
-      try {
-        const issue = await this.#client.request(
-          "GET",
-          `${API_PREFIX}/workspaces/${encodeURIComponent(workspaceId)}/issues/${encodeURIComponent(issueId)}?include=comments`
-        );
-        return { workspaceId, issue };
-      } catch (error) {
-        if (!isNotFound(error)) throw error;
-      }
-    }
-    return null;
-  }
-  async #resolveWorkspaceForIssue(sourceId, issueId) {
-    const workspaceIds = await this.#candidateWorkspaceIds(sourceId);
-    if (workspaceIds.length === 1) return workspaceIds[0];
-    for (const workspaceId of workspaceIds) {
-      try {
-        await this.#client.request(
-          "GET",
-          `${API_PREFIX}/workspaces/${encodeURIComponent(workspaceId)}/issues/${encodeURIComponent(issueId)}`
-        );
-        return workspaceId;
-      } catch (error) {
-        if (!isNotFound(error)) throw error;
-      }
-    }
-    return null;
-  }
-  async #listWorkflowStates(workspaceId, teamId) {
-    const cacheKey = `${workspaceId}:${teamId}`;
-    const cached = this.#workflowStatesByTeam.get(cacheKey);
-    if (cached) return cached;
-    const result = await this.#client.request(
-      "GET",
-      `${API_PREFIX}/workspaces/${encodeURIComponent(workspaceId)}/workflow-states?teamId=${encodeURIComponent(teamId)}&first=100`
-    );
-    this.#workflowStatesByTeam.set(cacheKey, result.workflowStates);
-    return result.workflowStates;
-  }
-  async #candidateWorkspaceIds(sourceId) {
-    if (sourceId) return [decodeSourceId(sourceId).workspaceId];
-    return (await this.#listWorkspaces()).map((workspace) => workspace.linearWorkspaceId);
-  }
-  async #loadComments(workspaceId, issueId, embedded) {
-    const comments = [...embedded?.nodes ?? []];
-    let pageInfo = embedded?.pageInfo;
-    let page = 0;
-    while (pageInfo?.hasNextPage && pageInfo.endCursor && page < MAX_COMMENT_PAGES) {
-      const result = await this.#client.request(
-        "GET",
-        `${API_PREFIX}/workspaces/${encodeURIComponent(workspaceId)}/issues/${encodeURIComponent(issueId)}/comments?first=200&after=${encodeURIComponent(pageInfo.endCursor)}`
-      );
-      comments.push(...result.comments);
-      pageInfo = result.pageInfo;
-      page += 1;
-    }
-    return comments;
-  }
+	id = "linear";
+	#client;
+	#endpointHost;
+	#projects;
+	#auth;
+	/**
+	* Per-instance workflow-state cache keyed by `${workspaceId}:${teamId}`. Scoped to the process
+	* lifetime; not shared across requests intentionally to keep failure modes simple (stale states
+	* clear on process restart). Populated lazily on first `updateIssue` per team.
+	*/
+	#workflowStatesByTeam = /* @__PURE__ */ new Map();
+	intake = {
+		resolveIntakeDispatch: (input) => this.#resolveIntakeDispatch(input),
+		listSources: async () => {
+			return (await this.#listProjectSources()).map(({ workspace, project }) => ({
+				id: encodeSourceId(workspace.linearWorkspaceId, project.id),
+				name: project.name,
+				type: "project",
+				metadata: {
+					workspaceId: workspace.linearWorkspaceId,
+					workspaceName: workspace.linearWorkspaceName,
+					workspaceUrlKey: workspace.urlKey,
+					state: project.state,
+					teams: project.teams
+				}
+			}));
+		},
+		listItems: async ({ sourceIds, cursor }) => {
+			const result = await this.#listIssues(sourceIds, cursor);
+			return {
+				items: result.issues.map(({ issue, source }) => ({
+					source: {
+						type: "issue",
+						externalId: issue.id,
+						url: issue.url
+					},
+					sourceId: encodeSourceId(source.workspace.linearWorkspaceId, source.project.id),
+					title: issue.title,
+					status: issue.state.name,
+					labels: issue.labels.map((label) => label.name),
+					assignee: issue.assignee?.displayName ?? issue.assignee?.name ?? null,
+					createdAt: issue.createdAt,
+					updatedAt: issue.updatedAt,
+					metadata: {
+						identifier: issue.identifier,
+						workspaceId: source.workspace.linearWorkspaceId,
+						workspaceName: source.workspace.linearWorkspaceName,
+						projectId: source.project.id,
+						projectName: source.project.name,
+						team: issue.team.key,
+						priority: issue.priorityLabel
+					}
+				})),
+				nextCursor: result.nextCursor
+			};
+		},
+		listIssues: async ({ connection, sourceIds, labels, cursor }) => {
+			requireLinearConnection(connection);
+			const result = await this.#listIssues(sourceIds, cursor, labels);
+			return {
+				issues: result.issues.map(({ issue }) => parseIssue(issue)),
+				nextCursor: result.nextCursor
+			};
+		},
+		getIssue: async ({ connection, sourceId, issueId }) => {
+			requireLinearConnection(connection);
+			const located = await this.#findIssue(sourceId, issueId);
+			if (!located) return null;
+			const comments = await this.#loadComments(located.workspaceId, issueId, located.issue.comments);
+			return parseIssueDetail(located.issue, comments);
+		},
+		createComment: async ({ connection, sourceId, issueId, body }) => {
+			requireLinearConnection(connection);
+			const workspaceId = await this.#resolveWorkspaceForIssue(sourceId, issueId);
+			if (!workspaceId) return null;
+			try {
+				const comment = await this.#client.request("POST", `${API_PREFIX}/workspaces/${encodeURIComponent(workspaceId)}/issues/${encodeURIComponent(issueId)}/comments`, { body });
+				return {
+					id: comment.id,
+					url: comment.url
+				};
+			} catch (error) {
+				if (isNotFound(error)) return null;
+				throw error;
+			}
+		},
+		updateIssue: async (input) => {
+			requireLinearConnection(input.connection);
+			const located = await this.#findIssue(input.sourceId, input.issueId);
+			if (!located) return null;
+			const { workspaceId, issue } = located;
+			const target = input.state;
+			if (target.kind === "byType" && issue.state.type === target.stateType) return parseIssue(issue);
+			if (target.kind === "byName" && issue.state.name.toLowerCase() === target.name.toLowerCase()) return parseIssue(issue);
+			let states;
+			try {
+				states = await this.#listWorkflowStates(workspaceId, issue.team.id);
+			} catch (error) {
+				if (isNotFound(error)) {
+					logPlatformWarn("Platform Linear: workflow-states endpoint not available; skipping updateIssue.", {
+						workspaceId,
+						teamId: issue.team.id
+					});
+					return null;
+				}
+				throw error;
+			}
+			let matched;
+			if (target.kind === "byType") matched = states.slice().sort((a, b) => a.position - b.position).find((s) => s.type === target.stateType);
+			else {
+				const wanted = target.name.toLowerCase();
+				matched = states.find((s) => s.name.toLowerCase() === wanted);
+			}
+			if (!matched) {
+				logPlatformWarn("Platform Linear: no workflow state matched target; skipping updateIssue.", {
+					workspaceId,
+					teamId: issue.team.id,
+					target
+				});
+				return null;
+			}
+			try {
+				await this.#client.request("PATCH", `${API_PREFIX}/workspaces/${encodeURIComponent(workspaceId)}/issues/${encodeURIComponent(input.issueId)}`, { stateId: matched.id });
+			} catch (error) {
+				if (isNotFound(error)) return null;
+				throw error;
+			}
+			const refreshed = await this.#findIssue(input.sourceId, input.issueId);
+			return refreshed ? parseIssue(refreshed.issue) : null;
+		}
+	};
+	constructor() {
+		const config = platformApiClientConfigFromEnv();
+		this.#client = new PlatformApiClient(config);
+		this.#endpointHost = new URL(config.baseUrl).host;
+	}
+	get storage() {
+		const now = /* @__PURE__ */ new Date();
+		return {
+			integrationId: this.id,
+			connections: { get: async (orgId) => ({
+				id: `platform-linear:${orgId}`,
+				orgId,
+				userId: null,
+				data: {
+					accessToken: PLATFORM_MANAGED_CONNECTION_TOKEN,
+					refreshToken: null,
+					expiresAtMs: null,
+					scope: "read,comments:create",
+					workspaceName: null,
+					workspaceUrlKey: null
+				},
+				metadata: {},
+				createdAt: now,
+				updatedAt: now
+			}) }
+		};
+	}
+	get projects() {
+		if (!this.#projects) throw new Error("PlatformLinearIntegration projects storage has not been initialized.");
+		return this.#projects;
+	}
+	initialize({ projects, auth }) {
+		this.#projects = projects;
+		this.#auth = auth;
+		logPlatformInfo("Platform Linear integration initialized", { endpointHost: this.#endpointHost });
+	}
+	get authEnabled() {
+		return this.#auth?.enabled() ?? false;
+	}
+	async resolveOrgId(resourceId) {
+		try {
+			return (await this.projects.getById({ id: resourceId }))?.orgId ?? null;
+		} catch {
+			return null;
+		}
+	}
+	async loadConnection(orgId) {
+		const workspace = (await this.#listWorkspaces())[0];
+		if (!workspace) return null;
+		const now = /* @__PURE__ */ new Date();
+		return {
+			id: `platform-linear:${orgId}`,
+			orgId,
+			userId: null,
+			accessToken: PLATFORM_MANAGED_CONNECTION_TOKEN,
+			scope: "read,comments:create",
+			refreshToken: null,
+			expiresAt: null,
+			workspaceName: workspace.linearWorkspaceName,
+			workspaceUrlKey: workspace.urlKey,
+			createdAt: now,
+			updatedAt: now
+		};
+	}
+	async getFreshAccessToken(_connection) {
+		return PLATFORM_MANAGED_CONNECTION_TOKEN;
+	}
+	/**
+	* Background-dispatch context: platform-managed connection token when the
+	* org has a connected workspace. Linear work items store the issue UUID
+	* directly as `externalId`.
+	*/
+	async #resolveIntakeDispatch({ orgId, externalSource }) {
+		if (externalSource.type !== "issue") return null;
+		if (!await this.loadConnection(orgId)) return null;
+		return {
+			connection: {
+				type: "oauth",
+				accessToken: PLATFORM_MANAGED_CONNECTION_TOKEN
+			},
+			issueId: externalSource.externalId
+		};
+	}
+	canPostComments(connection) {
+		return (connection.scope ?? "").split(/[\s,]+/).filter(Boolean).some((scope) => scope === "comments:create" || scope === "write" || scope === "admin");
+	}
+	async checkConnection(orgId) {
+		const connection = await this.loadConnection(orgId);
+		return {
+			connected: connection !== null,
+			canComment: connection !== null && this.canPostComments(connection),
+			checkedAt: Date.now()
+		};
+	}
+	routes(ctx) {
+		return [this.#connectRoute(ctx), ...buildLinearRoutes({
+			auth: ctx.auth,
+			linear: this,
+			stateSigner: ctx.stateSigner,
+			baseUrl: ctx.baseUrl,
+			intake: ctx.storage.intake,
+			ingestFactoryIssues: attachLinearRules(ctx)
+		}).filter((route) => !route.path.startsWith("/auth/linear/"))];
+	}
+	#connectRoute(ctx) {
+		return registerApiRoute("/auth/linear/connect", {
+			method: "GET",
+			requiresAuth: false,
+			handler: async (c) => {
+				await ctx.auth.ensureUser(loose(c));
+				const tenant = ctx.auth.tenant(loose(c));
+				if (!tenant?.orgId) return c.json({ error: "unauthorized" }, 401);
+				const returnTo = c.req.query("return_to") || "/";
+				const originator = routeBaseUrl(ctx, c.req.url);
+				logPlatformInfo("Starting Platform Linear connect flow", {
+					orgId: tenant.orgId,
+					returnTo,
+					originator
+				});
+				const query = new URLSearchParams({
+					return_to: returnTo,
+					originator
+				});
+				const location = await this.#client.requestRedirect("GET", `${API_PREFIX}/authorize?${query}`);
+				return c.redirect(location);
+			}
+		});
+	}
+	async agentTools({ requestContext }) {
+		return buildLinearAgentTools({
+			requestContext,
+			linear: this
+		});
+	}
+	diagnostics() {
+		return {
+			mode: "platform",
+			endpointHost: this.#endpointHost
+		};
+	}
+	async listProjects() {
+		return (await this.#listProjectSources()).map(({ workspace, project }) => ({
+			...project,
+			id: encodeSourceId(workspace.linearWorkspaceId, project.id),
+			workspaceId: workspace.linearWorkspaceId
+		}));
+	}
+	async #listProjectSources() {
+		const workspaces = await this.#listWorkspaces();
+		return (await Promise.all(workspaces.map(async (workspace) => {
+			const projects = [];
+			let after;
+			for (let page = 0; page < MAX_REFERENCE_PAGES; page += 1) {
+				const query = new URLSearchParams({ first: "200" });
+				if (after) query.set("after", after);
+				const result = await this.#client.request("GET", `${API_PREFIX}/workspaces/${encodeURIComponent(workspace.linearWorkspaceId)}/projects?${query}`);
+				projects.push(...result.projects);
+				if (!result.pageInfo.hasNextPage || !result.pageInfo.endCursor) break;
+				after = result.pageInfo.endCursor;
+			}
+			return projects.map((project) => ({
+				workspace,
+				project
+			}));
+		}))).flat();
+	}
+	async #listWorkspaces() {
+		return (await this.#client.request("GET", `${API_PREFIX}/workspaces`)).workspaces.filter((workspace) => workspace.connected);
+	}
+	async #listIssues(sourceIds, cursor, labels) {
+		if (sourceIds.length === 0) return {
+			issues: [],
+			nextCursor: null
+		};
+		const sources = await this.#listProjectSources();
+		const sourceMap = new Map(sources.map((source) => [encodeSourceId(source.workspace.linearWorkspaceId, source.project.id), source]));
+		const selected = sourceIds.map((sourceId) => sourceMap.get(sourceId)).filter((source) => !!source);
+		const cursors = decodeCursor(cursor, sourceIds);
+		const normalizedLabels = normalizeLabels(labels);
+		const nextState = {};
+		let hasNextPage = false;
+		return {
+			issues: (await Promise.all(selected.map(async (source) => {
+				const sourceId = encodeSourceId(source.workspace.linearWorkspaceId, source.project.id);
+				if (cursors[sourceId] === null) {
+					nextState[sourceId] = null;
+					return [];
+				}
+				const query = new URLSearchParams({
+					first: String(PAGE_SIZE),
+					projectIds: source.project.id,
+					stateType: "triage,backlog,unstarted,started",
+					orderBy: "updatedAt"
+				});
+				const after = cursors[sourceId];
+				if (after) query.set("after", after);
+				const result = await this.#client.request("GET", `${API_PREFIX}/workspaces/${encodeURIComponent(source.workspace.linearWorkspaceId)}/issues?${query}`);
+				const next = result.pageInfo.hasNextPage ? result.pageInfo.endCursor : null;
+				nextState[sourceId] = next;
+				hasNextPage ||= next !== null;
+				return result.issues.filter((issue) => normalizedLabels.length === 0 || issue.labels.some((label) => normalizedLabels.includes(label.name))).map((issue) => ({
+					issue,
+					source
+				}));
+			}))).flat(),
+			nextCursor: hasNextPage ? encodeCursor(nextState, sourceIds) : null
+		};
+	}
+	async #findIssue(sourceId, issueId) {
+		const workspaceIds = await this.#candidateWorkspaceIds(sourceId);
+		for (const workspaceId of workspaceIds) try {
+			return {
+				workspaceId,
+				issue: await this.#client.request("GET", `${API_PREFIX}/workspaces/${encodeURIComponent(workspaceId)}/issues/${encodeURIComponent(issueId)}?include=comments`)
+			};
+		} catch (error) {
+			if (!isNotFound(error)) throw error;
+		}
+		return null;
+	}
+	async #resolveWorkspaceForIssue(sourceId, issueId) {
+		const workspaceIds = await this.#candidateWorkspaceIds(sourceId);
+		if (workspaceIds.length === 1) return workspaceIds[0];
+		for (const workspaceId of workspaceIds) try {
+			await this.#client.request("GET", `${API_PREFIX}/workspaces/${encodeURIComponent(workspaceId)}/issues/${encodeURIComponent(issueId)}`);
+			return workspaceId;
+		} catch (error) {
+			if (!isNotFound(error)) throw error;
+		}
+		return null;
+	}
+	async #listWorkflowStates(workspaceId, teamId) {
+		const cacheKey = `${workspaceId}:${teamId}`;
+		const cached = this.#workflowStatesByTeam.get(cacheKey);
+		if (cached) return cached;
+		const result = await this.#client.request("GET", `${API_PREFIX}/workspaces/${encodeURIComponent(workspaceId)}/workflow-states?teamId=${encodeURIComponent(teamId)}&first=100`);
+		this.#workflowStatesByTeam.set(cacheKey, result.workflowStates);
+		return result.workflowStates;
+	}
+	async #candidateWorkspaceIds(sourceId) {
+		if (sourceId) return [decodeSourceId(sourceId).workspaceId];
+		return (await this.#listWorkspaces()).map((workspace) => workspace.linearWorkspaceId);
+	}
+	async #loadComments(workspaceId, issueId, embedded) {
+		const comments = [...embedded?.nodes ?? []];
+		let pageInfo = embedded?.pageInfo;
+		let page = 0;
+		while (pageInfo?.hasNextPage && pageInfo.endCursor && page < MAX_COMMENT_PAGES) {
+			const result = await this.#client.request("GET", `${API_PREFIX}/workspaces/${encodeURIComponent(workspaceId)}/issues/${encodeURIComponent(issueId)}/comments?first=200&after=${encodeURIComponent(pageInfo.endCursor)}`);
+			comments.push(...result.comments);
+			pageInfo = result.pageInfo;
+			page += 1;
+		}
+		return comments;
+	}
 };
 function parseIssue(issue) {
-  return {
-    id: issue.id,
-    identifier: issue.identifier,
-    title: issue.title,
-    url: issue.url,
-    author: issue.creator?.displayName ?? issue.creator?.name ?? null,
-    state: issue.state.name,
-    stateType: issue.state.type,
-    priority: issue.priorityLabel,
-    assignee: issue.assignee?.displayName ?? issue.assignee?.name ?? null,
-    source: issue.team.key,
-    labels: issue.labels.map((label) => label.name),
-    commentCount: null,
-    createdAt: issue.createdAt,
-    updatedAt: issue.updatedAt
-  };
+	return {
+		id: issue.id,
+		identifier: issue.identifier,
+		title: issue.title,
+		url: issue.url,
+		author: issue.creator?.displayName ?? issue.creator?.name ?? null,
+		state: issue.state.name,
+		stateType: issue.state.type,
+		priority: issue.priorityLabel,
+		assignee: issue.assignee?.displayName ?? issue.assignee?.name ?? null,
+		source: issue.team.key,
+		labels: issue.labels.map((label) => label.name),
+		commentCount: null,
+		createdAt: issue.createdAt,
+		updatedAt: issue.updatedAt
+	};
 }
 function parseIssueDetail(issue, comments) {
-  return {
-    ...parseIssue(issue),
-    commentCount: comments.length,
-    description: issue.description?.trim() ? issue.description : null,
-    comments: comments.map((comment) => ({
-      author: comment.user?.displayName ?? comment.user?.name ?? null,
-      body: comment.body,
-      createdAt: comment.createdAt
-    }))
-  };
+	return {
+		...parseIssue(issue),
+		commentCount: comments.length,
+		description: issue.description?.trim() ? issue.description : null,
+		comments: comments.map((comment) => ({
+			author: comment.user?.displayName ?? comment.user?.name ?? null,
+			body: comment.body,
+			createdAt: comment.createdAt
+		}))
+	};
 }
 function encodeSourceId(workspaceId, projectId) {
-  return `linear-project:${Buffer.from(JSON.stringify({ workspaceId, projectId })).toString("base64url")}`;
+	return `linear-project:${Buffer.from(JSON.stringify({
+		workspaceId,
+		projectId
+	})).toString("base64url")}`;
 }
 function decodeSourceId(sourceId) {
-  if (!sourceId.startsWith("linear-project:")) throw new Error("Linear project source id is invalid.");
-  try {
-    const parsed = JSON.parse(Buffer.from(sourceId.slice("linear-project:".length), "base64url").toString("utf8"));
-    if (typeof parsed.workspaceId !== "string" || !parsed.workspaceId) throw new Error();
-    if (typeof parsed.projectId !== "string" || !parsed.projectId) throw new Error();
-    return { workspaceId: parsed.workspaceId, projectId: parsed.projectId };
-  } catch {
-    throw new Error("Linear project source id is invalid.");
-  }
+	if (!sourceId.startsWith("linear-project:")) throw new Error("Linear project source id is invalid.");
+	try {
+		const parsed = JSON.parse(Buffer.from(sourceId.slice(15), "base64url").toString("utf8"));
+		if (typeof parsed.workspaceId !== "string" || !parsed.workspaceId) throw new Error();
+		if (typeof parsed.projectId !== "string" || !parsed.projectId) throw new Error();
+		return {
+			workspaceId: parsed.workspaceId,
+			projectId: parsed.projectId
+		};
+	} catch {
+		throw new Error("Linear project source id is invalid.");
+	}
 }
 function normalizeLabels(labels) {
-  return [...new Set((labels ?? []).map((label) => label.trim()).filter(Boolean))];
+	return [...new Set((labels ?? []).map((label) => label.trim()).filter(Boolean))];
 }
 function decodeCursor(cursor, sourceIds) {
-  if (!cursor) return {};
-  if (sourceIds.length === 1) return { [sourceIds[0]]: cursor };
-  try {
-    const parsed = JSON.parse(cursor);
-    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) throw new Error();
-    return parsed;
-  } catch {
-    throw new Error("Linear cursor is invalid.");
-  }
+	if (!cursor) return {};
+	if (sourceIds.length === 1) return { [sourceIds[0]]: cursor };
+	try {
+		const parsed = JSON.parse(cursor);
+		if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) throw new Error();
+		return parsed;
+	} catch {
+		throw new Error("Linear cursor is invalid.");
+	}
 }
 function encodeCursor(state, sourceIds) {
-  if (sourceIds.length === 1) return state[sourceIds[0]];
-  return JSON.stringify(state);
+	if (sourceIds.length === 1) return state[sourceIds[0]];
+	return JSON.stringify(state);
 }
 function requireLinearConnection(connection) {
-  if (connection.type !== "oauth") {
-    throw new Error("Linear capabilities require an OAuth connection.");
-  }
+	if (connection.type !== "oauth") throw new Error("Linear capabilities require an OAuth connection.");
 }
 function isNotFound(error) {
-  return error instanceof PlatformApiError && error.status === 404;
+	return error instanceof PlatformApiError && error.status === 404;
 }
-export {
-  PlatformLinearIntegration
-};
+//#endregion
+export { PlatformLinearIntegration };
+
 //# sourceMappingURL=integration.js.map