@mastra/factory 0.0.0-aggregate-trace-20261015182851

package/dist/integrations/base.d.ts

@@ -0,0 +1,302 @@
+/**
+ * `FactoryIntegration` — the common contract for pluggable web integrations
+ * (GitHub, Linear, third-party).
+ *
+ * Each integration is a self-contained class: the deploy entry
+ * (`src/mastra/index.ts`) reads that integration's env vars ONCE, constructs
+ * an instance with explicit credentials, and passes it to `MastraFactory`
+ * via `integrations: [...]`. The factory registers the pieces each instance
+ * provides — HTTP routes, agent/session tools, diagnostics — into the system.
+ * No system code reads integration env vars or imports integration free
+ * functions; everything downstream talks to instances through this interface.
+ *
+ * An absent integration means: its routes never mount, its tools never
+ * register, diagnostics report "not configured", and the server boots fine.
+ * Third parties add capabilities by implementing this same interface — no
+ * factory changes required (the same capability-based philosophy as the
+ * sandbox machine's `derive()` gate).
+ */
+import type { MastraCodeConfig, MountedMastraCode } from '@mastra/code-sdk';
+import type { AgentControllerChannelsConfig, ChannelAdapterConfig } from '@mastra/core/channels';
+import type { RequestContext } from '@mastra/core/request-context';
+import type { ApiRoute, IUserProvider } from '@mastra/core/server';
+import type { FactoryStorage } from '@mastra/core/storage';
+import type { MastraWorker } from '@mastra/core/worker';
+import type { FactorySandbox } from '@mastra/core/workspace';
+import type { BoardRegistry } from '../boards/index.js';
+import type { Intake } from '../capabilities/intake.js';
+import type { VersionControl } from '../capabilities/version-control.js';
+import type { RouteAuth } from '../routes/route.js';
+import type { SessionRetirementCoordinator } from '../sandbox/session-retirement.js';
+import type { StateSigner } from '../state-signing.js';
+import type { AuditEventRow } from '../storage/domains/audit/base.js';
+import type { AuditEmitter } from '../storage/domains/audit/domain.js';
+import type { ChannelIdentityStorage } from '../storage/domains/channel-identity/base.js';
+import type { CommentsDomain } from '../storage/domains/comments/domain.js';
+import type { WorkItemFeedPublisher } from '../storage/domains/comments/feed-sync.js';
+import type { IntakeStorage } from '../storage/domains/intake/base.js';
+import type { IntegrationStorageHandle } from '../storage/domains/integrations/base.js';
+import type { MemorySettingsStorage } from '../storage/domains/memory-settings/base.js';
+import type { ModelDefaultsStorage } from '../storage/domains/model-defaults/base.js';
+import type { FactoryProjectsStorage } from '../storage/domains/projects/base.js';
+import type { SourceControlStorageHandle } from '../storage/domains/source-control/base.js';
+import type { WorkItemsStorage } from '../storage/domains/work-items/base.js';
+/** A push to a repository linked to a project, as a version-control integration reports it. */
+export interface RepositoryPushEvent {
+    orgId: string;
+    factoryProjectId: string;
+    projectRepository: {
+        id: string;
+        inEnvironment: boolean;
+    };
+    /** The pushed git ref, for example `refs/heads/main`. */
+    ref: string;
+    /** The repository's default branch as the provider reports it. */
+    defaultBranch: string;
+}
+/** Factory-owned hooks integrations may invoke. */
+export interface IntegrationHooks {
+    emitAudit?: AuditEmitter['emit'];
+    /** Hand a push off for an environment build; never blocks the webhook and never throws. */
+    onRepositoryPush?: (event: RepositoryPushEvent) => void;
+}
+/**
+ * Tool records integrations contribute — the same static-record shape the
+ * SDK's `extraTools` accepts, so the factory can merge every integration's
+ * tools into one dynamic tool set.
+ */
+export type IntegrationTools = Extract<NonNullable<MastraCodeConfig['extraTools']>, Record<string, unknown>>;
+export interface IntegrationPostToolContext {
+    toolName: string;
+    input: unknown;
+    output?: unknown;
+    error?: unknown;
+    context: unknown;
+}
+/**
+ * Everything the factory hands an integration when collecting its routes.
+ * Built once per boot in `MastraFactory.prepare()`.
+ */
+export interface IntegrationContext {
+    /** Host auth seam — integration routes resolve callers through this. */
+    auth: RouteAuth;
+    /** Optional user directory for resolving persisted user ids to display profiles. */
+    users?: Pick<IUserProvider, 'getUser' | 'getUsers'>;
+    /**
+     * The deploy's sandbox callback for per-project and per-session
+     * sandboxes. Absent when no sandbox is configured — sandbox-backed
+     * routes respond 503.
+     */
+    sandbox?: FactorySandbox;
+    /**
+     * Root factory storage backend and source of the `appDbConfigured`
+     * diagnostic. Absent when the host runs without an application database.
+     */
+    factoryStorage?: FactoryStorage;
+    /** Browser-facing origin (OAuth redirect base), no trailing slash. */
+    baseUrl?: string;
+    /** Mounted agent controller for webhook → session signal delivery. */
+    controller?: MountedMastraCode['controller'];
+    /**
+     * Shared OAuth state signer created by the factory. One signer per boot, so
+     * every integration's OAuth flow signs and verifies with the same secret.
+     */
+    stateSigner?: StateSigner;
+    /** Shared source-control session retirement lifecycle used by integration routes. */
+    sessionRetirement?: SessionRetirementCoordinator;
+    /** Work-items domain slice — deleting a session strips the refs work items hold on it. */
+    workItems?: Pick<WorkItemsStorage, 'clearSessionReferences'>;
+    /** Feed slice for ingesting platform messages; present once work items are ready. */
+    feed?: Pick<CommentsDomain, 'createComment'>;
+    /** Persistence handles pre-scoped to this integration's stable id. */
+    storage: {
+        generic: IntegrationStorageHandle;
+        sourceControl: SourceControlStorageHandle;
+        /**
+         * The factory's source-control-owning integration's storage handle
+         * (today: GitHub when registered; the handle carries its own
+         * `integrationId`). Channel integrations use it to make sessions
+         * repo-backed without the entry hand-wiring a source-control slice.
+         * Absent when no source-control owner is registered.
+         */
+        sourceControlOwner?: SourceControlStorageHandle;
+        /** Every registered source-control partition, for project-aware provider selection. */
+        sourceControls: readonly SourceControlStorageHandle[];
+        /** Factory projects domain — e.g. resolving a project's default model. */
+        projects: FactoryProjectsStorage;
+        /**
+         * Observational-memory settings domain, so a session an integration starts
+         * adopts the same memory configuration the web kickoff applies.
+         */
+        memorySettings: MemorySettingsStorage;
+        /**
+         * Per-user default model. A channel integration reads the linked sender's
+         * default to start a session on the model that user chose rather than the
+         * factory's shared default.
+         */
+        modelDefaults: ModelDefaultsStorage;
+        /** Cross-integration intake selection (which sources are synced). */
+        intake: IntakeStorage;
+        /**
+         * Reverse index from a chat-platform sender to a Mastra tenant. Channel
+         * integrations resolve an inbound sender through this to run under the
+         * right user's credentials.
+         */
+        channelIdentity: ChannelIdentityStorage;
+    };
+    /**
+     * Factory runtime available when the work-item domain is ready.
+     * Integrations attach their own provider event rules to their ingress
+     * surfaces instead of relying on provider-specific services in the host.
+     */
+    runtime?: {
+        /** Operator-maintained provenance label stamped on audit rows. */
+        configVersion: string;
+        workItems: WorkItemsStorage;
+        /** Installed boards, so integrations read phase semantics instead of matching names. */
+        boards: BoardRegistry;
+    };
+    /** System hooks integrations may invoke. */
+    hooks?: IntegrationHooks;
+}
+/**
+ * One adapter entry in a {@link FactoryChannelsConfig} adapter map.
+ *
+ * Core's adapter-map entry is `ChannelAdapterConfig | Adapter<any, any>`, and
+ * `ChannelAdapterConfig` is itself a union — so this MUST be a type alias, not
+ * an interface extends (illegal on unions). Factory's contract deliberately
+ * EXCLUDES the bare-`Adapter` shorthand core accepts: entries use the config
+ * form so future per-platform extras (e.g. a `resolveWorkspaceId`, connect
+ * handlers) have a home. Today the alias adds no fields; it is the stable
+ * extension point.
+ */
+export type FactoryChannelAdapterEntry = ChannelAdapterConfig;
+/**
+ * The channels contribution a {@link FactoryIntegration} returns from
+ * `channels()`. A config object, not a built instance — the factory constructs
+ * the `AgentControllerChannels` at the attach site.
+ *
+ * The adapter-map key is the platform identity (`'slack'`, `'discord'`, …).
+ * One integration = one platform = one entry is the norm: the map shape is
+ * inherited from core (one `AgentControllerChannels` instance drives multiple
+ * adapters) and is where cross-integration merging will happen later — it is
+ * NOT an invitation for a single integration to bundle multiple platforms.
+ * Note the top-level `handlers` and resolvers are shared across all adapters
+ * in the map. Entries use the config form; the bare-`Adapter` shorthand core
+ * accepts is deliberately excluded (see {@link FactoryChannelAdapterEntry}).
+ */
+export interface FactoryChannelsConfig extends Omit<AgentControllerChannelsConfig, 'adapters'> {
+    adapters: Record<string, FactoryChannelAdapterEntry>;
+}
+/**
+ * A pluggable web integration. Implementations own their credentials
+ * (validated at construction), their API surface, and their HTTP routes.
+ */
+export interface FactoryIntegration {
+    /** Stable identifier: `'github'`, `'linear'`, custom ids for third parties. */
+    readonly id: string;
+    /** Issue-oriented capability consumed by Intake. */
+    readonly intake?: Intake;
+    /** Repository, installation, and pull-request capability. */
+    readonly versionControl?: VersionControl;
+    /**
+     * Bind the integration's generic persistence handle. Called once by the
+     * factory during `prepare()` (before routes/tools/workers are collected),
+     * so instance methods that run outside an `IntegrationContext` — per-request
+     * agent tools, intake capability calls — reach storage without a service
+     * locator. Mirrors `sourceControl.initialize`.
+     */
+    initialize?(args: {
+        storage: IntegrationStorageHandle;
+        projects: FactoryProjectsStorage;
+        auth: RouteAuth;
+        /** Cross-integration intake selection/binding domain, for per-request authorization. */
+        intake: IntakeStorage;
+        sourceControl?: SourceControlStorageHandle;
+    }): void;
+    /**
+     * The integration's full HTTP surface (status, OAuth, webhooks, feature
+     * routes), as Mastra `apiRoutes`. Called once at boot; the factory folds
+     * the result into the server's route table.
+     */
+    routes(ctx: IntegrationContext): ApiRoute[];
+    /**
+     * Org-scoped agent tools resolved per request (e.g. Linear's issue tools).
+     * Optional capability; the factory merges results into the SDK's async
+     * `extraTools` provider.
+     */
+    agentTools?(args: {
+        requestContext: RequestContext;
+    }): Promise<IntegrationTools>;
+    /**
+     * Session-scoped tools (e.g. GitHub's PR subscribe/unsubscribe). Optional
+     * capability, resolved synchronously per request.
+     */
+    sessionTools?(args: {
+        requestContext: RequestContext;
+    }): IntegrationTools;
+    /**
+     * Optional provider-owned observer for successful or failed tool calls.
+     * The factory invokes every configured observer independently so one
+     * integration cannot prevent another from observing the same tool result.
+     */
+    postToolObserver?(args: {
+        toolContext: IntegrationPostToolContext;
+        requestContext?: RequestContext;
+    }): Promise<void>;
+    /**
+     * Background workers the integration needs running for its lifecycle
+     * (e.g. polling an upstream that doesn't support webhooks). Optional
+     * capability: called once at boot for READY integrations only; the factory
+     * folds the returned workers into the server Mastra's `workers` option, so
+     * they are merged with the built-in workers and started with them
+     * (`startWorkers()`). Worker names must be unique across integrations —
+     * duplicates fail the `new Mastra(...)` construction loudly.
+     */
+    workers?(ctx: IntegrationContext): MastraWorker[];
+    /**
+     * Chat-platform channels this integration contributes (Slack, Discord, …).
+     * Called once at boot for READY integrations only; the factory constructs an
+     * `AgentControllerChannels` from the returned config and attaches it to the
+     * mounted agent controller via `setChannels`, so inbound platform messages
+     * reach the same agents the web UI drives.
+     *
+     * An integration providing this slot also declares a dependency on the
+     * `channel-identity` domain, which the factory folds into its readiness
+     * gate — so an integration whose reverse index isn't migrated yet reports
+     * not-ready and its channels never attach, rather than dispatching runs it
+     * can't resolve a tenant for.
+     *
+     * Only one integration may provide channels; the factory fails loud at boot
+     * on a second, because `setChannels` replaces rather than merges and the
+     * loser would silently never receive a message.
+     */
+    channels?(ctx: IntegrationContext): FactoryChannelsConfig;
+    /**
+     * Mirrors web feed comments outward — to the platform thread a work item is
+     * bound to, a webhook, or an issue tracker. Collected from every READY
+     * integration independent of `channels()`: an integration may publish without
+     * owning a chat channel.
+     */
+    feedPublisher?(ctx: IntegrationContext): WorkItemFeedPublisher;
+    /**
+     * Non-secret config snapshot (booleans + names only, never values). The
+     * factory merges it into system diagnostics/startup logs.
+     */
+    diagnostics(): Record<string, unknown>;
+    /**
+     * Optional best-effort destination for locally persisted audit events.
+     * Audit export remains independent of the configured web auth adapter.
+     */
+    audit?(args: {
+        event: AuditEventRow;
+    }): Promise<void>;
+    /**
+     * True when the integration signs OAuth `state` and therefore needs a
+     * replica-stable signer. The factory fails loud at boot when a registered
+     * integration requires stability but only a per-process random secret is
+     * available (see `./state-signing.ts`).
+     */
+    readonly requiresStableStateSigner?: boolean;
+}
+//# sourceMappingURL=base.d.ts.map

package/dist/integrations/base.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"base.d.ts","sourceRoot":"","sources":["../../src/integrations/base.ts"],"names":[],"mappings":"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"}

package/dist/integrations/base.js

@@ -0,0 +1 @@
+export {};

package/dist/integrations/github/acceptance-labels.d.ts

@@ -0,0 +1,16 @@
+import type { SourceControlStorageHandle } from '../../storage/domains/source-control/base.js';
+import type { WorkItemRow } from '../../storage/domains/work-items/base.js';
+import type { GithubIntegration } from './integration.js';
+export interface ReconcileAcceptanceLabelsInput {
+    orgId: string;
+    factoryProjectId: string;
+    item: WorkItemRow;
+}
+/**
+ * Reflect a maintainer's acceptance of a triaged GitHub issue back on the
+ * issue: the triage skill stamps `status: needs approval` and never removes it,
+ * so the approval gesture on the board is the only point that can clear it.
+ * Best-effort — every failure is a warning, never a rejected transition.
+ */
+export declare function reconcileGithubAcceptanceLabels(github: GithubIntegration, sourceControl: SourceControlStorageHandle, input: ReconcileAcceptanceLabelsInput): Promise<void>;
+//# sourceMappingURL=acceptance-labels.d.ts.map

package/dist/integrations/github/acceptance-labels.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"acceptance-labels.d.ts","sourceRoot":"","sources":["../../../src/integrations/github/acceptance-labels.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,8CAA8C,CAAC;AAC/F,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,0CAA0C,CAAC;AAC5E,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AAE1D,MAAM,WAAW,8BAA8B;IAC7C,KAAK,EAAE,MAAM,CAAC;IACd,gBAAgB,EAAE,MAAM,CAAC;IACzB,IAAI,EAAE,WAAW,CAAC;CACnB;AAED;;;;;GAKG;AACH,wBAAsB,+BAA+B,CACnD,MAAM,EAAE,iBAAiB,EACzB,aAAa,EAAE,0BAA0B,EACzC,KAAK,EAAE,8BAA8B,GACpC,OAAO,CAAC,IAAI,CAAC,CAgBf"}

package/dist/integrations/github/acceptance-labels.js

@@ -0,0 +1,55 @@
+import { NEEDS_APPROVAL_LABEL } from "../../rules/types.js";
+//#region src/integrations/github/acceptance-labels.ts
+/**
+* Reflect a maintainer's acceptance of a triaged GitHub issue back on the
+* issue: the triage skill stamps `status: needs approval` and never removes it,
+* so the approval gesture on the board is the only point that can clear it.
+* Best-effort — every failure is a warning, never a rejected transition.
+*/
+async function reconcileGithubAcceptanceLabels(github, sourceControl, input) {
+	const { item } = input;
+	if (item.externalSource?.integrationId !== "github" || item.externalSource.type !== "issue") return;
+	const repositoryId = item.metadata?.githubRepositoryId;
+	const issueNumber = item.metadata?.githubIssueNumber;
+	if (typeof repositoryId !== "number" || typeof issueNumber !== "number" || issueNumber < 1) return;
+	try {
+		const target = await resolveRepository(sourceControl, input.orgId, input.factoryProjectId, repositoryId);
+		if (!target) return;
+		await github.removeIssueLabel(target.installationId, target.slug, issueNumber, NEEDS_APPROVAL_LABEL);
+	} catch (error) {
+		if (error.status === 404) return;
+		console.warn(`[factory] could not clear "${NEEDS_APPROVAL_LABEL}" for work item ${item.id}:`, error);
+	}
+}
+async function resolveRepository(sourceControl, orgId, factoryProjectId, externalRepositoryId) {
+	for (const connection of await sourceControl.connections.list({
+		orgId,
+		factoryProjectId
+	})) {
+		const installation = await sourceControl.installations.get({
+			orgId,
+			id: connection.installationId
+		});
+		if (!installation) continue;
+		for (const link of await sourceControl.projectRepositories.list({
+			orgId,
+			connectionId: connection.id
+		})) {
+			const repository = await sourceControl.repositories.get({
+				orgId,
+				id: link.repositoryId
+			});
+			if (!repository || Number(repository.externalId) !== externalRepositoryId) continue;
+			const installationId = Number(installation.externalId);
+			if (!Number.isInteger(installationId)) return void 0;
+			return {
+				installationId,
+				slug: repository.slug
+			};
+		}
+	}
+}
+//#endregion
+export { reconcileGithubAcceptanceLabels };
+
+//# sourceMappingURL=acceptance-labels.js.map

package/dist/integrations/github/acceptance-labels.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"acceptance-labels.js","names":[],"sources":["../../../src/integrations/github/acceptance-labels.ts"],"sourcesContent":["import { NEEDS_APPROVAL_LABEL } from '../../rules/types.js';\nimport type { SourceControlStorageHandle } from '../../storage/domains/source-control/base.js';\nimport type { WorkItemRow } from '../../storage/domains/work-items/base.js';\nimport type { GithubIntegration } from './integration.js';\n\nexport interface ReconcileAcceptanceLabelsInput {\n  orgId: string;\n  factoryProjectId: string;\n  item: WorkItemRow;\n}\n\n/**\n * Reflect a maintainer's acceptance of a triaged GitHub issue back on the\n * issue: the triage skill stamps `status: needs approval` and never removes it,\n * so the approval gesture on the board is the only point that can clear it.\n * Best-effort — every failure is a warning, never a rejected transition.\n */\nexport async function reconcileGithubAcceptanceLabels(\n  github: GithubIntegration,\n  sourceControl: SourceControlStorageHandle,\n  input: ReconcileAcceptanceLabelsInput,\n): Promise<void> {\n  const { item } = input;\n  if (item.externalSource?.integrationId !== 'github' || item.externalSource.type !== 'issue') return;\n  const repositoryId = item.metadata?.githubRepositoryId;\n  const issueNumber = item.metadata?.githubIssueNumber;\n  if (typeof repositoryId !== 'number' || typeof issueNumber !== 'number' || issueNumber < 1) return;\n\n  try {\n    const target = await resolveRepository(sourceControl, input.orgId, input.factoryProjectId, repositoryId);\n    if (!target) return;\n    await github.removeIssueLabel(target.installationId, target.slug, issueNumber, NEEDS_APPROVAL_LABEL);\n  } catch (error) {\n    // GitHub answers 404 when the label is not on the issue; nothing to clear.\n    if ((error as { status?: number }).status === 404) return;\n    console.warn(`[factory] could not clear \"${NEEDS_APPROVAL_LABEL}\" for work item ${item.id}:`, error);\n  }\n}\n\nasync function resolveRepository(\n  sourceControl: SourceControlStorageHandle,\n  orgId: string,\n  factoryProjectId: string,\n  externalRepositoryId: number,\n): Promise<{ installationId: number; slug: string } | undefined> {\n  for (const connection of await sourceControl.connections.list({ orgId, factoryProjectId })) {\n    const installation = await sourceControl.installations.get({ orgId, id: connection.installationId });\n    if (!installation) continue;\n    for (const link of await sourceControl.projectRepositories.list({ orgId, connectionId: connection.id })) {\n      const repository = await sourceControl.repositories.get({ orgId, id: link.repositoryId });\n      if (!repository || Number(repository.externalId) !== externalRepositoryId) continue;\n      const installationId = Number(installation.externalId);\n      if (!Number.isInteger(installationId)) return undefined;\n      return { installationId, slug: repository.slug };\n    }\n  }\n  return undefined;\n}\n"],"mappings":";;;;;;;;AAiBA,eAAsB,gCACpB,QACA,eACA,OACe;CACf,MAAM,EAAE,SAAS;CACjB,IAAI,KAAK,gBAAgB,kBAAkB,YAAY,KAAK,eAAe,SAAS,SAAS;CAC7F,MAAM,eAAe,KAAK,UAAU;CACpC,MAAM,cAAc,KAAK,UAAU;CACnC,IAAI,OAAO,iBAAiB,YAAY,OAAO,gBAAgB,YAAY,cAAc,GAAG;CAE5F,IAAI;EACF,MAAM,SAAS,MAAM,kBAAkB,eAAe,MAAM,OAAO,MAAM,kBAAkB,YAAY;EACvG,IAAI,CAAC,QAAQ;EACb,MAAM,OAAO,iBAAiB,OAAO,gBAAgB,OAAO,MAAM,aAAa,oBAAoB;CACrG,SAAS,OAAO;EAEd,IAAK,MAA8B,WAAW,KAAK;EACnD,QAAQ,KAAK,8BAA8B,qBAAqB,kBAAkB,KAAK,GAAG,IAAI,KAAK;CACrG;AACF;AAEA,eAAe,kBACb,eACA,OACA,kBACA,sBAC+D;CAC/D,KAAK,MAAM,cAAc,MAAM,cAAc,YAAY,KAAK;EAAE;EAAO;CAAiB,CAAC,GAAG;EAC1F,MAAM,eAAe,MAAM,cAAc,cAAc,IAAI;GAAE;GAAO,IAAI,WAAW;EAAe,CAAC;EACnG,IAAI,CAAC,cAAc;EACnB,KAAK,MAAM,QAAQ,MAAM,cAAc,oBAAoB,KAAK;GAAE;GAAO,cAAc,WAAW;EAAG,CAAC,GAAG;GACvG,MAAM,aAAa,MAAM,cAAc,aAAa,IAAI;IAAE;IAAO,IAAI,KAAK;GAAa,CAAC;GACxF,IAAI,CAAC,cAAc,OAAO,WAAW,UAAU,MAAM,sBAAsB;GAC3E,MAAM,iBAAiB,OAAO,aAAa,UAAU;GACrD,IAAI,CAAC,OAAO,UAAU,cAAc,GAAG,OAAO,KAAA;GAC9C,OAAO;IAAE;IAAgB,MAAM,WAAW;GAAK;EACjD;CACF;AAEF"}

package/dist/integrations/github/app-identity.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Factory's own GitHub identity.
+ *
+ * Factory must recognise its own writes, or it wakes itself: a handoff comment
+ * arrives back through ingress, fires the rule that authored it, and cancels the
+ * run mid-flight. Every self-loop guard depends on answering "is this me?".
+ *
+ * The answer is not free. On a Platform deployment the credentials that post as
+ * `mastra-platform[bot]` do not carry that login, and `GITHUB_APP_SLUG`
+ * describes a *different*, self-hosted App — so it is legitimately unset. A bare
+ * `login === `${slug}[bot]`` therefore compares against `undefined[bot]`, never
+ * matches, and silently disables every guard while looking correct.
+ *
+ * Two sources, in order of trust:
+ *
+ * 1. **Observed.** Every comment Factory creates comes back with its author.
+ *    That is authoritative, costs no extra request, and needs no configuration —
+ *    Factory learns its own name the first time it speaks.
+ * 2. **Configured.** `slug` from a self-hosted GitHub App, when present.
+ *
+ * When neither is available the identity is *unknown*, which is distinct from
+ * "not Factory". Callers must handle it explicitly rather than inherit a `false`.
+ */
+export declare class GithubAppIdentity {
+    #private;
+    constructor(slug?: string);
+    /** The login Factory posts as, or `undefined` when it cannot be determined. */
+    get login(): string | undefined;
+    /** True once Factory can recognise its own writes. */
+    get known(): boolean;
+    /**
+     * Record the author GitHub reported for a write Factory just made. Observed
+     * identity wins over configuration: it is what GitHub actually attributes the
+     * write to, whereas the slug is a claim about a possibly-different App.
+     */
+    observeSelfAuthor(login: string | null | undefined): void;
+    /**
+     * Whether `login` is Factory. Returns `false` when the identity is unknown —
+     * callers that must not fail open should check {@link known} first.
+     */
+    matches(login: string | null | undefined): boolean;
+}
+//# sourceMappingURL=app-identity.d.ts.map

package/dist/integrations/github/app-identity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"app-identity.d.ts","sourceRoot":"","sources":["../../../src/integrations/github/app-identity.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,qBAAa,iBAAiB;;gBAIhB,IAAI,CAAC,EAAE,MAAM;IAKzB,+EAA+E;IAC/E,IAAI,KAAK,IAAI,MAAM,GAAG,SAAS,CAE9B;IAED,sDAAsD;IACtD,IAAI,KAAK,IAAI,OAAO,CAEnB;IAED;;;;OAIG;IACH,iBAAiB,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GAAG,IAAI;IAKzD;;;OAGG;IACH,OAAO,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GAAG,OAAO;CAKnD"}

package/dist/integrations/github/app-identity.js

@@ -0,0 +1,62 @@
+//#region src/integrations/github/app-identity.ts
+/**
+* Factory's own GitHub identity.
+*
+* Factory must recognise its own writes, or it wakes itself: a handoff comment
+* arrives back through ingress, fires the rule that authored it, and cancels the
+* run mid-flight. Every self-loop guard depends on answering "is this me?".
+*
+* The answer is not free. On a Platform deployment the credentials that post as
+* `mastra-platform[bot]` do not carry that login, and `GITHUB_APP_SLUG`
+* describes a *different*, self-hosted App — so it is legitimately unset. A bare
+* `login === `${slug}[bot]`` therefore compares against `undefined[bot]`, never
+* matches, and silently disables every guard while looking correct.
+*
+* Two sources, in order of trust:
+*
+* 1. **Observed.** Every comment Factory creates comes back with its author.
+*    That is authoritative, costs no extra request, and needs no configuration —
+*    Factory learns its own name the first time it speaks.
+* 2. **Configured.** `slug` from a self-hosted GitHub App, when present.
+*
+* When neither is available the identity is *unknown*, which is distinct from
+* "not Factory". Callers must handle it explicitly rather than inherit a `false`.
+*/
+var GithubAppIdentity = class {
+	#configuredLogin;
+	#observedLogin;
+	constructor(slug) {
+		const trimmed = slug?.trim();
+		this.#configuredLogin = trimmed ? `${trimmed.toLowerCase()}[bot]` : void 0;
+	}
+	/** The login Factory posts as, or `undefined` when it cannot be determined. */
+	get login() {
+		return this.#observedLogin ?? this.#configuredLogin;
+	}
+	/** True once Factory can recognise its own writes. */
+	get known() {
+		return this.login !== void 0;
+	}
+	/**
+	* Record the author GitHub reported for a write Factory just made. Observed
+	* identity wins over configuration: it is what GitHub actually attributes the
+	* write to, whereas the slug is a claim about a possibly-different App.
+	*/
+	observeSelfAuthor(login) {
+		const trimmed = login?.trim().toLowerCase();
+		if (trimmed) this.#observedLogin = trimmed;
+	}
+	/**
+	* Whether `login` is Factory. Returns `false` when the identity is unknown —
+	* callers that must not fail open should check {@link known} first.
+	*/
+	matches(login) {
+		const self = this.login;
+		if (!self || !login) return false;
+		return login.trim().toLowerCase() === self;
+	}
+};
+//#endregion
+export { GithubAppIdentity };
+
+//# sourceMappingURL=app-identity.js.map

package/dist/integrations/github/app-identity.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"app-identity.js","names":["#configuredLogin","#observedLogin"],"sources":["../../../src/integrations/github/app-identity.ts"],"sourcesContent":["/**\n * Factory's own GitHub identity.\n *\n * Factory must recognise its own writes, or it wakes itself: a handoff comment\n * arrives back through ingress, fires the rule that authored it, and cancels the\n * run mid-flight. Every self-loop guard depends on answering \"is this me?\".\n *\n * The answer is not free. On a Platform deployment the credentials that post as\n * `mastra-platform[bot]` do not carry that login, and `GITHUB_APP_SLUG`\n * describes a *different*, self-hosted App — so it is legitimately unset. A bare\n * `login === `${slug}[bot]`` therefore compares against `undefined[bot]`, never\n * matches, and silently disables every guard while looking correct.\n *\n * Two sources, in order of trust:\n *\n * 1. **Observed.** Every comment Factory creates comes back with its author.\n *    That is authoritative, costs no extra request, and needs no configuration —\n *    Factory learns its own name the first time it speaks.\n * 2. **Configured.** `slug` from a self-hosted GitHub App, when present.\n *\n * When neither is available the identity is *unknown*, which is distinct from\n * \"not Factory\". Callers must handle it explicitly rather than inherit a `false`.\n */\nexport class GithubAppIdentity {\n  #configuredLogin: string | undefined;\n  #observedLogin: string | undefined;\n\n  constructor(slug?: string) {\n    const trimmed = slug?.trim();\n    this.#configuredLogin = trimmed ? `${trimmed.toLowerCase()}[bot]` : undefined;\n  }\n\n  /** The login Factory posts as, or `undefined` when it cannot be determined. */\n  get login(): string | undefined {\n    return this.#observedLogin ?? this.#configuredLogin;\n  }\n\n  /** True once Factory can recognise its own writes. */\n  get known(): boolean {\n    return this.login !== undefined;\n  }\n\n  /**\n   * Record the author GitHub reported for a write Factory just made. Observed\n   * identity wins over configuration: it is what GitHub actually attributes the\n   * write to, whereas the slug is a claim about a possibly-different App.\n   */\n  observeSelfAuthor(login: string | null | undefined): void {\n    const trimmed = login?.trim().toLowerCase();\n    if (trimmed) this.#observedLogin = trimmed;\n  }\n\n  /**\n   * Whether `login` is Factory. Returns `false` when the identity is unknown —\n   * callers that must not fail open should check {@link known} first.\n   */\n  matches(login: string | null | undefined): boolean {\n    const self = this.login;\n    if (!self || !login) return false;\n    return login.trim().toLowerCase() === self;\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;AAuBA,IAAa,oBAAb,MAA+B;CAC7B;CACA;CAEA,YAAY,MAAe;EACzB,MAAM,UAAU,MAAM,KAAK;EAC3B,KAAKA,mBAAmB,UAAU,GAAG,QAAQ,YAAY,EAAE,SAAS,KAAA;CACtE;;CAGA,IAAI,QAA4B;EAC9B,OAAO,KAAKC,kBAAkB,KAAKD;CACrC;;CAGA,IAAI,QAAiB;EACnB,OAAO,KAAK,UAAU,KAAA;CACxB;;;;;;CAOA,kBAAkB,OAAwC;EACxD,MAAM,UAAU,OAAO,KAAK,CAAC,CAAC,YAAY;EAC1C,IAAI,SAAS,KAAKC,iBAAiB;CACrC;;;;;CAMA,QAAQ,OAA2C;EACjD,MAAM,OAAO,KAAK;EAClB,IAAI,CAAC,QAAQ,CAAC,OAAO,OAAO;EAC5B,OAAO,MAAM,KAAK,CAAC,CAAC,YAAY,MAAM;CACxC;AACF"}

package/dist/integrations/github/commits.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Read with the installation token that already clones and pushes, not through
+ * `getInstallationOctokit`: the Platform deployment answers that with a
+ * pull-request-only stub, so `repos.*` is undefined there at runtime while the
+ * cast keeps the compiler quiet.
+ */
+import type { VersionControl } from '../../capabilities/version-control.js';
+export interface RepositoryCommit {
+    sha: string;
+    message: string;
+    author: string | null;
+    avatarUrl: string | null;
+    committedAt: string | null;
+    url: string;
+}
+export declare function listRepositoryCommits(github: {
+    versionControl: Pick<VersionControl, 'getRepositoryAccess'>;
+}, input: {
+    orgId: string;
+    project: {
+        repository: {
+            id: string;
+            slug: string;
+        };
+    };
+    branch: string;
+    limit: number;
+}): Promise<RepositoryCommit[]>;
+/** The commit a branch points at right now, as a full sha. Throws when GitHub rejects the lookup. */
+export declare function getBranchHead(github: {
+    versionControl: Pick<VersionControl, 'getRepositoryAccess'>;
+}, input: {
+    orgId: string;
+    repository: {
+        id: string;
+        slug: string;
+    };
+    branch: string;
+}): Promise<string>;
+//# sourceMappingURL=commits.d.ts.map

package/dist/integrations/github/commits.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"commits.d.ts","sourceRoot":"","sources":["../../../src/integrations/github/commits.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uCAAuC,CAAC;AAI5E,MAAM,WAAW,gBAAgB;IAC/B,GAAG,EAAE,MAAM,CAAC;IACZ,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IACtB,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,GAAG,EAAE,MAAM,CAAC;CACb;AASD,wBAAsB,qBAAqB,CACzC,MAAM,EAAE;IAAE,cAAc,EAAE,IAAI,CAAC,cAAc,EAAE,qBAAqB,CAAC,CAAA;CAAE,EACvE,KAAK,EAAE;IACL,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE;QAAE,UAAU,EAAE;YAAE,EAAE,EAAE,MAAM,CAAC;YAAC,IAAI,EAAE,MAAM,CAAA;SAAE,CAAA;KAAE,CAAC;IACtD,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;CACf,GACA,OAAO,CAAC,gBAAgB,EAAE,CAAC,CA2B7B;AAID,qGAAqG;AACrG,wBAAsB,aAAa,CACjC,MAAM,EAAE;IAAE,cAAc,EAAE,IAAI,CAAC,cAAc,EAAE,qBAAqB,CAAC,CAAA;CAAE,EACvE,KAAK,EAAE;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,GACjF,OAAO,CAAC,MAAM,CAAC,CA0BjB"}

package/dist/integrations/github/commits.js

@@ -0,0 +1,48 @@
+//#region src/integrations/github/commits.ts
+const GITHUB_API = "https://api.github.com";
+async function listRepositoryCommits(github, input) {
+	const access = await github.versionControl.getRepositoryAccess({
+		orgId: input.orgId,
+		repositoryId: input.project.repository.id
+	});
+	const query = new URLSearchParams({
+		sha: input.branch,
+		per_page: String(input.limit)
+	});
+	const response = await fetch(`${GITHUB_API}/repos/${input.project.repository.slug}/commits?${query}`, { headers: {
+		accept: "application/vnd.github+json",
+		...access.authorization ? { authorization: `Bearer ${access.authorization.token}` } : {}
+	} });
+	if (!response.ok) throw new Error(`GitHub rejected the commit listing for ${input.project.repository.slug} (${response.status}).`);
+	return (await response.json()).map((entry) => ({
+		sha: entry.sha,
+		message: entry.commit.message.split("\n")[0] ?? "",
+		author: entry.author?.login ?? entry.commit.author?.name ?? null,
+		avatarUrl: entry.author?.avatar_url ?? null,
+		committedAt: entry.commit.author?.date ?? null,
+		url: entry.html_url
+	}));
+}
+const SHA_PATTERN = /^[0-9a-f]{40}$/;
+/** The commit a branch points at right now, as a full sha. Throws when GitHub rejects the lookup. */
+async function getBranchHead(github, input) {
+	const access = await github.versionControl.getRepositoryAccess({
+		orgId: input.orgId,
+		repositoryId: input.repository.id
+	});
+	const response = await fetch(`${GITHUB_API}/repos/${input.repository.slug}/commits/${encodeURIComponent(input.branch)}`, {
+		headers: {
+			accept: "application/vnd.github.sha",
+			...access.authorization ? { authorization: `Bearer ${access.authorization.token}` } : {}
+		},
+		signal: AbortSignal.timeout(1e4)
+	});
+	if (!response.ok) throw new Error(`GitHub rejected the head lookup for ${input.repository.slug}@${input.branch} (${response.status}).`);
+	const sha = (await response.text()).trim();
+	if (!SHA_PATTERN.test(sha)) throw new Error(`GitHub returned no commit sha for ${input.repository.slug}@${input.branch}.`);
+	return sha;
+}
+//#endregion
+export { getBranchHead, listRepositoryCommits };
+
+//# sourceMappingURL=commits.js.map

package/dist/integrations/github/commits.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"commits.js","names":[],"sources":["../../../src/integrations/github/commits.ts"],"sourcesContent":["/**\n * Read with the installation token that already clones and pushes, not through\n * `getInstallationOctokit`: the Platform deployment answers that with a\n * pull-request-only stub, so `repos.*` is undefined there at runtime while the\n * cast keeps the compiler quiet.\n */\n\nimport type { VersionControl } from '../../capabilities/version-control.js';\n\nconst GITHUB_API = 'https://api.github.com';\n\nexport interface RepositoryCommit {\n  sha: string;\n  message: string;\n  author: string | null;\n  avatarUrl: string | null;\n  committedAt: string | null;\n  url: string;\n}\n\ninterface GithubCommitResponse {\n  sha: string;\n  html_url: string;\n  commit: { message: string; author: { name?: string; date?: string } | null };\n  author: { login: string; avatar_url: string } | null;\n}\n\nexport async function listRepositoryCommits(\n  github: { versionControl: Pick<VersionControl, 'getRepositoryAccess'> },\n  input: {\n    orgId: string;\n    project: { repository: { id: string; slug: string } };\n    branch: string;\n    limit: number;\n  },\n): Promise<RepositoryCommit[]> {\n  const access = await github.versionControl.getRepositoryAccess({\n    orgId: input.orgId,\n    repositoryId: input.project.repository.id,\n  });\n\n  const query = new URLSearchParams({ sha: input.branch, per_page: String(input.limit) });\n  const response = await fetch(`${GITHUB_API}/repos/${input.project.repository.slug}/commits?${query}`, {\n    headers: {\n      accept: 'application/vnd.github+json',\n      ...(access.authorization ? { authorization: `Bearer ${access.authorization.token}` } : {}),\n    },\n  });\n\n  if (!response.ok) {\n    throw new Error(`GitHub rejected the commit listing for ${input.project.repository.slug} (${response.status}).`);\n  }\n\n  const commits = (await response.json()) as GithubCommitResponse[];\n  return commits.map(entry => ({\n    sha: entry.sha,\n    message: entry.commit.message.split('\\n')[0] ?? '',\n    author: entry.author?.login ?? entry.commit.author?.name ?? null,\n    avatarUrl: entry.author?.avatar_url ?? null,\n    committedAt: entry.commit.author?.date ?? null,\n    url: entry.html_url,\n  }));\n}\n\nconst SHA_PATTERN = /^[0-9a-f]{40}$/;\n\n/** The commit a branch points at right now, as a full sha. Throws when GitHub rejects the lookup. */\nexport async function getBranchHead(\n  github: { versionControl: Pick<VersionControl, 'getRepositoryAccess'> },\n  input: { orgId: string; repository: { id: string; slug: string }; branch: string },\n): Promise<string> {\n  const access = await github.versionControl.getRepositoryAccess({\n    orgId: input.orgId,\n    repositoryId: input.repository.id,\n  });\n\n  const response = await fetch(\n    `${GITHUB_API}/repos/${input.repository.slug}/commits/${encodeURIComponent(input.branch)}`,\n    {\n      headers: {\n        accept: 'application/vnd.github.sha',\n        ...(access.authorization ? { authorization: `Bearer ${access.authorization.token}` } : {}),\n      },\n      signal: AbortSignal.timeout(10_000),\n    },\n  );\n\n  if (!response.ok) {\n    throw new Error(`GitHub rejected the head lookup for ${input.repository.slug}@${input.branch} (${response.status}).`);\n  }\n\n  const sha = (await response.text()).trim();\n  if (!SHA_PATTERN.test(sha)) {\n    throw new Error(`GitHub returned no commit sha for ${input.repository.slug}@${input.branch}.`);\n  }\n  return sha;\n}\n"],"mappings":";AASA,MAAM,aAAa;AAkBnB,eAAsB,sBACpB,QACA,OAM6B;CAC7B,MAAM,SAAS,MAAM,OAAO,eAAe,oBAAoB;EAC7D,OAAO,MAAM;EACb,cAAc,MAAM,QAAQ,WAAW;CACzC,CAAC;CAED,MAAM,QAAQ,IAAI,gBAAgB;EAAE,KAAK,MAAM;EAAQ,UAAU,OAAO,MAAM,KAAK;CAAE,CAAC;CACtF,MAAM,WAAW,MAAM,MAAM,GAAG,WAAW,SAAS,MAAM,QAAQ,WAAW,KAAK,WAAW,SAAS,EACpG,SAAS;EACP,QAAQ;EACR,GAAI,OAAO,gBAAgB,EAAE,eAAe,UAAU,OAAO,cAAc,QAAQ,IAAI,CAAC;CAC1F,EACF,CAAC;CAED,IAAI,CAAC,SAAS,IACZ,MAAM,IAAI,MAAM,0CAA0C,MAAM,QAAQ,WAAW,KAAK,IAAI,SAAS,OAAO,GAAG;CAIjH,QAAO,MADgB,SAAS,KAAK,EAAA,CACtB,KAAI,WAAU;EAC3B,KAAK,MAAM;EACX,SAAS,MAAM,OAAO,QAAQ,MAAM,IAAI,CAAC,CAAC,MAAM;EAChD,QAAQ,MAAM,QAAQ,SAAS,MAAM,OAAO,QAAQ,QAAQ;EAC5D,WAAW,MAAM,QAAQ,cAAc;EACvC,aAAa,MAAM,OAAO,QAAQ,QAAQ;EAC1C,KAAK,MAAM;CACb,EAAE;AACJ;AAEA,MAAM,cAAc;;AAGpB,eAAsB,cACpB,QACA,OACiB;CACjB,MAAM,SAAS,MAAM,OAAO,eAAe,oBAAoB;EAC7D,OAAO,MAAM;EACb,cAAc,MAAM,WAAW;CACjC,CAAC;CAED,MAAM,WAAW,MAAM,MACrB,GAAG,WAAW,SAAS,MAAM,WAAW,KAAK,WAAW,mBAAmB,MAAM,MAAM,KACvF;EACE,SAAS;GACP,QAAQ;GACR,GAAI,OAAO,gBAAgB,EAAE,eAAe,UAAU,OAAO,cAAc,QAAQ,IAAI,CAAC;EAC1F;EACA,QAAQ,YAAY,QAAQ,GAAM;CACpC,CACF;CAEA,IAAI,CAAC,SAAS,IACZ,MAAM,IAAI,MAAM,uCAAuC,MAAM,WAAW,KAAK,GAAG,MAAM,OAAO,IAAI,SAAS,OAAO,GAAG;CAGtH,MAAM,OAAO,MAAM,SAAS,KAAK,EAAA,CAAG,KAAK;CACzC,IAAI,CAAC,YAAY,KAAK,GAAG,GACvB,MAAM,IAAI,MAAM,qCAAqC,MAAM,WAAW,KAAK,GAAG,MAAM,OAAO,EAAE;CAE/F,OAAO;AACT"}