@sentry/junior 0.182.0 → 0.184.0

package/dist/{catalog-runtime-ESLMBQBV.js → catalog-runtime-5357XR4F.js}

@@ -1,14 +1,14 @@
 import {
   pluginCatalogRuntime
-} from "./chunk-WOIALVN2.js";
-import "./chunk-4DZ62L36.js";
+} from "./chunk-PJPRXO2T.js";
+import "./chunk-LHXIZLFF.js";
 import "./chunk-CEMMLV5L.js";
 import "./chunk-N7TMSOZH.js";
 import "./chunk-DWPN6SCH.js";
 import "./chunk-TXKUKMVO.js";
-import "./chunk-UQP54CXZ.js";
+import "./chunk-3S7ULUWW.js";
 import "./chunk-PEQXYSSE.js";
-import "./chunk-BZD4ADQH.js";
+import "./chunk-6VOYP4M6.js";
 export {
   pluginCatalogRuntime
 };

package/dist/chat/agent-invocations/store.d.ts

@@ -40,5 +40,7 @@ export declare function completeAgentInvocation(args: {
     status: "blocked" | "failed";
     nowMs?: number;
 }): Promise<AgentInvocation | undefined>;
-/** Return whether an invocation already owns its immutable terminal result. */
-export declare function isTerminalAgentInvocation(invocation: AgentInvocation): boolean;
+/** Return whether an agent invocation has finished. */
+export declare function isTerminalAgentInvocation(invocation: AgentInvocation): invocation is Extract<AgentInvocation, {
+    status: "blocked" | "completed" | "failed";
+}>;

package/dist/chat/agent-invocations/work.d.ts

@@ -20,9 +20,7 @@ export declare function createAndEnqueueAgentInvocation(input: CreateAgentInvoca
 /** Resolve invocation execution from mailbox input or durable active state. */
 export declare function resolveAgentInvocationId(context: ConversationWorkerContext): Promise<string | undefined>;
 /** Build the invocation consumer that advances work through the shared runner. */
-export declare function createAgentInvocationWorker(options: {
-    agentRunner: AgentRunner;
-}): (context: ConversationWorkerContext, invocationId: string) => Promise<ConversationWorkerResult>;
+export declare function createAgentInvocationWorker(agentRunner: AgentRunner): (context: ConversationWorkerContext, invocationId: string) => Promise<ConversationWorkerResult>;
 /** Route invocation-backed work before falling through to existing consumers. */
 export declare function routeAgentInvocationWork(options: {
     fallbackWorker: (context: ConversationWorkerContext) => Promise<ConversationWorkerResult>;

package/dist/chat/app/factory.d.ts

@@ -1,6 +1,6 @@
 import type { SlackAdapter } from "@chat-adapter/slack";
 import type { Message } from "chat";
-import { type AssistantLifecycleEvent } from "@/chat/runtime/slack-runtime";
+import { type AssistantLifecycleEvent } from "@/chat/providers/slack/runtime";
 import type { JuniorRuntimeServiceOverrides } from "@/chat/app/services";
 export interface CreateSlackRuntimeOptions {
     getSlackAdapter: () => SlackAdapter;
@@ -14,6 +14,6 @@ export declare function createSlackRuntime(options: CreateSlackRuntimeOptions):
     }) => Promise<import("../agent-dispatch/types").DispatchTurnResult>;
     handleAssistantContextChanged: (event: AssistantLifecycleEvent) => Promise<void>;
     handleAssistantThreadStarted: (event: AssistantLifecycleEvent) => Promise<void>;
-    handleNewMention: (thread: import("chat").Thread, message: Message, hooks: import("@/chat/runtime/slack-runtime").SlackTurnOptions) => Promise<void>;
-    handleSubscribedMessage: (thread: import("chat").Thread, message: Message, hooks: import("@/chat/runtime/slack-runtime").SlackTurnOptions) => Promise<void>;
+    handleNewMention: (thread: import("chat").Thread, message: Message, hooks: import("@/chat/providers/slack/runtime").SlackTurnOptions) => Promise<void>;
+    handleSubscribedMessage: (thread: import("chat").Thread, message: Message, hooks: import("@/chat/providers/slack/runtime").SlackTurnOptions) => Promise<void>;
 };

package/dist/chat/app/services.d.ts

@@ -2,19 +2,19 @@ import type { SandboxEgressTracePropagationConfig } from "@/chat/sandbox/egress/
 import { type ConversationMemoryDeps, type ConversationMemoryService } from "@/chat/services/conversation-memory";
 import { type ContextCompactor, type ContextCompactorDeps } from "@/chat/services/context-compaction";
 import { type SubscribedReplyPolicy, type SubscribedReplyPolicyDeps } from "@/chat/services/subscribed-reply-policy";
-import type { ReplyExecutorServices } from "@/chat/runtime/reply-executor";
+import type { SlackTurnServices } from "@/chat/providers/slack/turn";
 import { type VisionContextDeps, type VisionContextService } from "@/chat/slack/vision-context";
 export interface JuniorRuntimeServices {
     conversationMemory: ConversationMemoryService;
     contextCompactor: ContextCompactor;
-    replyExecutor: ReplyExecutorServices;
+    replyExecutor: SlackTurnServices;
     subscribedReplyPolicy: SubscribedReplyPolicy;
     visionContext: VisionContextService;
 }
 export interface JuniorRuntimeServiceOverrides {
     conversationMemory?: Partial<ConversationMemoryDeps>;
     contextCompactor?: Partial<ContextCompactorDeps>;
-    replyExecutor?: Partial<ReplyExecutorServices>;
+    replyExecutor?: Partial<SlackTurnServices>;
     subscribedReplyPolicy?: Partial<SubscribedReplyPolicyDeps>;
     sandbox?: {
         tracePropagation?: SandboxEgressTracePropagationConfig;

package/dist/chat/code/publisher.d.ts

@@ -0,0 +1,3 @@
+import type { CodeChangePublisher } from "@sentry/junior-plugin-api";
+/** Connect a plugin to Junior's code records. */
+export declare function createCodeChangePublisher(provider: string): CodeChangePublisher;

package/dist/chat/code/store.d.ts

@@ -0,0 +1,9 @@
+import { type CodeChangeInput } from "@sentry/junior-plugin-api";
+import type { JuniorDatabase } from "@/db/db";
+/** Record the latest details for one code change created by Junior. */
+export declare function recordCodeChange(db: JuniorDatabase, provider: string, input: CodeChangeInput): Promise<void>;
+/** Add conversation links to an existing code change. */
+export declare function associateCodeChangeConversations(db: JuniorDatabase, provider: string, input: {
+    conversationIds: string[];
+    providerId: string;
+}): Promise<void>;

package/dist/chat/event-tasks/store.d.ts

@@ -17,5 +17,15 @@ export declare function eventTaskBelongsToUser(task: EventTask, user: User): boo
 export declare function listEventTasksCreatedBy(db: JuniorDatabase, user: User, limit: number): Promise<EventTask[]>;
 /** List event tasks whose current Slack destination is public. */
 export declare function listPublicEventTasksForTeams(db: JuniorDatabase, teamIds: string[], limit: number): Promise<EventTask[]>;
+/**
+ * Collect match keys from event tasks for these identifiers and event types.
+ * Does not evaluate match values — only reports keys that filters use.
+ */
+export declare function collectEventTaskMatchKeys(db: JuniorDatabase, input: {
+    eventTypes: string[];
+    identifiers: string[];
+    namespace: string;
+    teamId: string;
+}): Promise<string[]>;
 /** Find every task matching one normalized resource event. */
 export declare function findMatchingEventTasks(db: JuniorDatabase, event: ResourceEvent, teamId: string): Promise<EventTask[]>;

package/dist/chat/ingress/slack-webhook.d.ts

@@ -1,6 +1,6 @@
 import type { SlackAdapter } from "@chat-adapter/slack";
 import { type StateAdapter } from "chat";
-import type { SlackTurnRuntime } from "@/chat/runtime/slack-runtime";
+import type { SlackTurnRuntime } from "@/chat/providers/slack/runtime";
 import type { ConversationStore } from "@/chat/conversations/store";
 import type { ConversationWorkQueue } from "@/chat/task-execution/queue";
 import type { UserTokenStore } from "@/chat/credentials/user-token-store";

package/dist/chat/plugins/agent-hooks.d.ts

@@ -61,6 +61,11 @@ export declare function getPluginTools(context: ToolRuntimeContext, sandbox?: Pl
 /** Collect route handlers exposed by plugins for app-level mounting. */
 export declare function getPluginRoutes(options: {
     resourceEvents: {
+        neededMatchKeys?(input: {
+            eventTypes: string[];
+            identifiers: string[];
+            namespace: string;
+        }): Promise<string[]>;
         publish(event: ResourceEvent): Promise<void>;
     };
 }): PluginRouteRegistration[];

package/dist/chat/{runtime/slack-runtime.d.ts → providers/slack/runtime.d.ts}

@@ -1,5 +1,5 @@
 /**
- * Slack event runtime.
+ * Slack provider runtime.
  *
  * This module owns inbound Slack routing decisions for mentions, subscribed
  * messages, assistant lifecycle events, and retryable turn pauses. It should
@@ -93,7 +93,7 @@ export interface SlackTurnRuntimeDependencies<TPreparedState> {
         thread: Thread;
     }) => Promise<void>;
     prepareTurnState: (args: PrepareTurnStateInput) => Promise<TPreparedState>;
-    replyToThread: (thread: Thread, message: Message, options: {
+    executeSlackTurn: (thread: Thread, message: Message, options: {
         beforeFirstResponsePost?: () => Promise<void>;
         conversationId?: string;
         destination: Destination;

package/dist/chat/{runtime/reply-executor.d.ts → providers/slack/turn.d.ts}

@@ -1,10 +1,10 @@
 /**
- * Slack reply execution boundary.
+ * Add Slack provider behavior around one native agent Turn.
  *
- * This module bridges prepared Slack thread state into the agent runner
- * and commits the resulting Slack-visible delivery/state updates. It is where
- * queued messages, compaction, status updates, and Slack posting meet; agent
- * internals stay behind the runner seam.
+ * This module prepares Slack input and owns Slack status, delivery, and saved
+ * Slack state. Native execution concerns that remain here must move behind a
+ * provider-neutral runtime contract. Agent execution stays behind
+ * `AgentRunner`.
  */
 import type { Message, Thread } from "chat";
 import type { SlackAdapter } from "@chat-adapter/slack";
@@ -17,7 +17,7 @@ import { lookupSlackUser } from "@/chat/slack/user";
 import type { PausedTurnRequest } from "@/chat/task-execution/turn-wake";
 import type { ConversationTurnLifecycle } from "@/chat/conversations/turn-lifecycle";
 import type { DispatchTurnContext, DispatchTurnResult } from "@/chat/agent-dispatch/types";
-export interface ReplyExecutorServices {
+export interface SlackTurnServices {
     agentRunner: AgentRunner;
     contextCompactor: ContextCompactor;
     getPausedTurnRequest: (args: {
@@ -32,7 +32,7 @@ export interface ReplyExecutorServices {
         sessionId: string;
     }) => Promise<void>;
 }
-interface ReplyExecutorDeps {
+interface SlackTurnDeps {
     getSlackAdapter: () => SlackAdapter;
     resolveUserAttachments: (attachments: Message["attachments"] | undefined, context: {
         threadId?: string;
@@ -48,9 +48,10 @@ interface ReplyExecutorDeps {
         promptText?: string;
     }>>;
     prepareTurnState: (args: PrepareTurnStateInput) => Promise<PreparedTurnState>;
-    services: ReplyExecutorServices;
+    services: SlackTurnServices;
 }
-export declare function createReplyToThread(deps: ReplyExecutorDeps): (thread: Thread, message: Message, options: {
+/** Build the Slack caller that prepares input and delivers output for a Turn. */
+export declare function createSlackTurn(deps: SlackTurnDeps): (thread: Thread, message: Message, options: {
     beforeFirstResponsePost?: () => Promise<void>;
     conversationId?: string;
     destination: Destination;

package/dist/chat/resource-events/store.d.ts

@@ -65,6 +65,18 @@ export declare function cancelSubscriptions(input: {
     nowMs?: number;
     state?: StateAdapter;
 }): Promise<void>;
+/**
+ * Collect match keys from active watches for these identifiers and event types.
+ * Does not evaluate match values — only reports keys that filters use.
+ */
+export declare function collectResourceEventMatchKeys(input: {
+    eventTypes: string[];
+    identifiers: string[];
+    namespace: string;
+    nowMs?: number;
+    state?: StateAdapter;
+    teamId: string;
+}): Promise<string[]>;
 /** Find active subscriptions interested in a normalized resource event. */
 export declare function findMatchingResourceEventSubscriptions(input: {
     data?: ResourceEventData;

package/dist/chat/runtime/turn-execution.d.ts

@@ -0,0 +1,30 @@
+import type { AgentRun } from "@/chat/agent/types";
+import type { CompleteConversationTurnInput, FailConversationTurnInput } from "@/chat/conversations/turn-lifecycle";
+import type { AgentRunOutcome } from "@/chat/runtime/agent-run-outcome";
+import type { AgentRunner } from "@/chat/runtime/agent-runner";
+import type { AgentRunResult } from "@/chat/services/turn-result";
+type SavedTurnResult = {
+    finishedAtMs?: number;
+    outcome: CompleteConversationTurnInput["outcome"];
+} | {
+    finishedAtMs?: number;
+    failureCode: FailConversationTurnInput["failureCode"];
+    outcome: "failed";
+};
+type TurnExecutionOutcome = Exclude<AgentRunOutcome, {
+    status: "completed";
+}> | {
+    status: "completed";
+};
+/** An error thrown while the agent advances a Run. */
+export declare class AgentRunError extends Error {
+    constructor(cause: unknown);
+}
+/**
+ * Run the agent and finish the Turn after the caller saves its result.
+ *
+ * A paused Run, or a Run waiting for authorization, leaves the Turn open. A
+ * save error also leaves the Turn open so the worker can retry or recover it.
+ */
+export declare function executeTurn(agentRunner: AgentRunner, run: AgentRun, saveResult: (result: AgentRunResult) => Promise<SavedTurnResult>): Promise<TurnExecutionOutcome>;
+export {};

package/dist/chat/slack/dispatch-turn.d.ts

@@ -2,24 +2,22 @@ import { Message, ThreadImpl } from "chat";
 import type { SlackAdapter } from "@chat-adapter/slack";
 import type { DispatchTurnContext, DispatchTurnResult } from "@/chat/agent-dispatch/types";
 import type { DispatchRecord } from "@/chat/agent-dispatch/types";
-interface DispatchReplyToThread {
-    (thread: ThreadImpl, message: Message, options: {
-        ack?: () => Promise<void>;
-        conversationId?: string;
-        destination: DispatchRecord["destination"];
-        execution: DispatchTurnContext;
-        publishExternally?: boolean;
-        onTurnDeliveryAccepted?: (messageId?: string) => void;
-        onTurnOutcome?: (result: DispatchTurnResult) => void;
-        shouldYield?: () => boolean;
-        skipBackfill?: boolean;
-    }): Promise<void>;
-}
+type ExecuteSlackTurn = (thread: ThreadImpl, message: Message, options: {
+    ack?: () => Promise<void>;
+    conversationId?: string;
+    destination: DispatchRecord["destination"];
+    execution: DispatchTurnContext;
+    publishExternally?: boolean;
+    onTurnDeliveryAccepted?: (messageId?: string) => void;
+    onTurnOutcome?: (result: DispatchTurnResult) => void;
+    shouldYield?: () => boolean;
+    skipBackfill?: boolean;
+}) => Promise<void>;
 /** Build the Slack provider adapter for agent-dispatched conversation turns. */
 export declare function createSlackDispatchTurnRunner(options: {
     getLocationConfiguration: (destination: DispatchRecord["destination"]) => DispatchTurnContext["locationConfiguration"];
     getSlackAdapter: () => SlackAdapter;
-    replyToThread: DispatchReplyToThread;
+    executeSlackTurn: ExecuteSlackTurn;
 }): (dispatch: DispatchRecord, hooks: {
     ack: () => Promise<void>;
     shouldYield?: () => boolean;

package/dist/chat/task-execution/slack-work.d.ts

@@ -1,7 +1,7 @@
 import type { SlackAdapter } from "@chat-adapter/slack";
 import { Message, ThreadImpl, type StateAdapter } from "chat";
 import { z } from "zod";
-import type { SlackTurnOptions } from "@/chat/runtime/slack-runtime";
+import type { SlackTurnOptions } from "@/chat/providers/slack/runtime";
 import type { ConversationStore } from "@/chat/conversations/store";
 import type { InboundMessage } from "@/chat/task-execution/store";
 import type { ConversationWorkerContext, ConversationWorkerResult } from "@/chat/task-execution/worker";

package/dist/{chunk-SXOZIG5X.js → chunk-2ZQPVX7C.js}

@@ -3,7 +3,7 @@ import {
 } from "./chunk-PDO5BLNM.js";
 import {
   ToolInputError
-} from "./chunk-2CEOXDG2.js";
+} from "./chunk-4CNDGK25.js";
 import {
   agentHistoryItemSchema,
   bindProviderConversation,
@@ -16,25 +16,25 @@ import {
   instructionProvenanceFor,
   sanitizePostgresJson,
   withConversationEventLock
-} from "./chunk-6TSWXBTQ.js";
+} from "./chunk-IZDYYYGP.js";
 import {
   SANDBOX_REPOS_ROOT,
   SANDBOX_WORKSPACE_ROOT,
   sleep
-} from "./chunk-UKIHNBBD.js";
+} from "./chunk-SHJK75Z2.js";
 import {
   MUTATION_LOCK_TTL_MS,
   fenceLock,
   getStateAdapter,
   withLock
-} from "./chunk-Z7ALSQS3.js";
+} from "./chunk-DUKIDPF6.js";
 import {
   botConfig,
   completeText,
   escapeXml,
   resolveGatewayModel,
   unwrapCurrentInstruction
-} from "./chunk-LHQK5XCU.js";
+} from "./chunk-6UDPINOX.js";
 import {
   parseSlackMessageTs,
   toStoredSlackActor
@@ -44,7 +44,7 @@ import {
   logException,
   logWarn,
   setSpanAttributes
-} from "./chunk-UQP54CXZ.js";
+} from "./chunk-3S7ULUWW.js";
 
 // src/chat/turn-context-tag.ts
 var TURN_CONTEXT_TAG = "runtime-turn-context";

package/dist/{chunk-UQP54CXZ.js → chunk-3S7ULUWW.js}

@@ -12,7 +12,7 @@ import {
 } from "./chunk-PEQXYSSE.js";
 import {
   JUNIOR_VERSION
-} from "./chunk-BZD4ADQH.js";
+} from "./chunk-6VOYP4M6.js";
 
 // src/deployment.ts
 var JUNIOR_HEARTBEAT_ROUTE = "/api/internal/heartbeat";

package/dist/{chunk-2CEOXDG2.js → chunk-4CNDGK25.js}

@@ -5,8 +5,10 @@ import {
   getConversationEventStore,
   getDb,
   getSqlExecutor
-} from "./chunk-6TSWXBTQ.js";
+} from "./chunk-IZDYYYGP.js";
 import {
+  juniorCodeChanges,
+  juniorCodeRepositories,
   juniorConversationAnnotations,
   juniorConversationEvents,
   juniorIdentities,
@@ -14,7 +16,7 @@ import {
   juniorUsers,
   juniorWorkspaceRepos,
   juniorWorkspaces
-} from "./chunk-44BQ3TSK.js";
+} from "./chunk-BCHYQS4B.js";
 import {
   SANDBOX_WORKSPACE_ROOT,
   getVercelSandboxCredentials,
@@ -22,17 +24,17 @@ import {
   isSandboxMissingError,
   runNonInteractiveCommand,
   sleep
-} from "./chunk-UKIHNBBD.js";
+} from "./chunk-SHJK75Z2.js";
 import {
   getStateAdapter
-} from "./chunk-Z7ALSQS3.js";
+} from "./chunk-DUKIDPF6.js";
 import {
   botConfig,
   completeObject,
   defaultModelId,
   embedTexts,
   getSlackBotToken
-} from "./chunk-LHQK5XCU.js";
+} from "./chunk-6UDPINOX.js";
 import {
   isActorUserId,
   parseActorUserId,
@@ -48,7 +50,7 @@ import {
   setSpanAttributes,
   setSpanStatus,
   withSpan
-} from "./chunk-UQP54CXZ.js";
+} from "./chunk-3S7ULUWW.js";
 
 // src/chat/plugins/agent-hooks.ts
 import {
@@ -1218,6 +1220,42 @@ async function cancelSubscriptions(input) {
     });
   }
 }
+async function collectResourceEventMatchKeys(input) {
+  const state = input.state ?? getStateAdapter();
+  await state.connect();
+  const nowMs = input.nowMs ?? Date.now();
+  const eventTypes = new Set(
+    input.eventTypes.map((eventType) => eventType.trim()).filter(Boolean)
+  );
+  if (eventTypes.size === 0) return [];
+  const keys = /* @__PURE__ */ new Set();
+  const identifiers = new Set(
+    input.identifiers.map((value) => value.trim()).filter(Boolean)
+  );
+  for (const identifier of identifiers) {
+    const ids = await readSubscriptionIdIndex(
+      state,
+      resourceIndexKey(input.teamId, input.namespace, identifier)
+    );
+    const records = await Promise.all(
+      ids.map(
+        async (id) => parseSubscription(await state.get(subscriptionKey(id)))
+      )
+    );
+    for (const record of records) {
+      if (!record) continue;
+      if (record.namespace !== input.namespace) continue;
+      if (record.identifier !== identifier) continue;
+      if (subscriptionTeamId(record.destination) !== input.teamId) continue;
+      if (!activeAt(record, nowMs)) continue;
+      if (!record.events.some((eventType) => eventTypes.has(eventType))) continue;
+      for (const key of Object.keys(record.match ?? {})) {
+        keys.add(key);
+      }
+    }
+  }
+  return [...keys].sort();
+}
 async function findMatchingResourceEventSubscriptions(input) {
   const state = input.state ?? getStateAdapter();
   await state.connect();
@@ -2178,6 +2216,113 @@ async function deleteWorkspace(id) {
   return result.deleted;
 }
 
+// src/chat/code/store.ts
+import { randomUUID as randomUUID3 } from "crypto";
+import { and as and6, eq as eq6, lte, sql as sql3 } from "drizzle-orm";
+import {
+  codeChangeInputSchema
+} from "@sentry/junior-plugin-api";
+async function recordCodeChange(db, provider, input) {
+  const change = codeChangeInputSchema.parse(input);
+  const repositories = await db.insert(juniorCodeRepositories).values({
+    id: randomUUID3(),
+    name: change.repository.name,
+    provider,
+    providerId: change.repository.providerId,
+    url: change.repository.url,
+    updatedAt: change.updatedAt
+  }).onConflictDoUpdate({
+    target: [
+      juniorCodeRepositories.provider,
+      juniorCodeRepositories.providerId
+    ],
+    set: {
+      name: change.repository.name,
+      ...change.repository.url ? { url: change.repository.url } : void 0,
+      updatedAt: change.updatedAt
+    },
+    where: lte(juniorCodeRepositories.updatedAt, change.updatedAt)
+  }).returning({ id: juniorCodeRepositories.id });
+  const existingRepositories = repositories[0] ? [] : await db.select({ id: juniorCodeRepositories.id }).from(juniorCodeRepositories).where(
+    and6(
+      eq6(juniorCodeRepositories.provider, provider),
+      eq6(juniorCodeRepositories.providerId, change.repository.providerId)
+    )
+  ).limit(1);
+  const repositoryId = repositories[0]?.id ?? existingRepositories[0]?.id;
+  if (!repositoryId) {
+    throw new Error("Code repository upsert returned no row");
+  }
+  const conversationIds = sql3.join(
+    change.conversationIds.map((conversationId) => sql3`${conversationId}`),
+    sql3`, `
+  );
+  const values = {
+    closedAt: change.closedAt ?? null,
+    conversationIds: change.conversationIds.length > 0 ? sql3`ARRAY(
+            SELECT DISTINCT value
+            FROM unnest(
+              ${juniorCodeChanges.conversationIds}
+              || ARRAY[${conversationIds}]::text[]
+            ) AS value
+            ORDER BY value
+          )` : juniorCodeChanges.conversationIds,
+    mergedAt: change.mergedAt ?? null,
+    number: change.number,
+    openedAt: change.openedAt,
+    repositoryId,
+    state: change.state,
+    ...change.title ? { title: change.title } : void 0,
+    updatedAt: change.updatedAt,
+    url: change.url ?? null
+  };
+  await db.insert(juniorCodeChanges).values({
+    ...values,
+    conversationIds: change.conversationIds,
+    id: randomUUID3(),
+    provider,
+    providerId: change.providerId
+  }).onConflictDoUpdate({
+    target: [juniorCodeChanges.provider, juniorCodeChanges.providerId],
+    set: values,
+    where: lte(juniorCodeChanges.updatedAt, change.updatedAt)
+  });
+}
+async function associateCodeChangeConversations(db, provider, input) {
+  if (input.conversationIds.length === 0) return;
+  const conversationIds = sql3.join(
+    input.conversationIds.map((conversationId) => sql3`${conversationId}`),
+    sql3`, `
+  );
+  await db.update(juniorCodeChanges).set({
+    conversationIds: sql3`ARRAY(
+        SELECT DISTINCT value
+        FROM unnest(
+          ${juniorCodeChanges.conversationIds}
+          || ARRAY[${conversationIds}]::text[]
+        ) AS value
+        ORDER BY value
+      )`
+  }).where(
+    and6(
+      eq6(juniorCodeChanges.provider, provider),
+      eq6(juniorCodeChanges.providerId, input.providerId)
+    )
+  );
+}
+
+// src/chat/code/publisher.ts
+function createCodeChangePublisher(provider) {
+  return {
+    async associateConversations(input) {
+      await associateCodeChangeConversations(getDb(), provider, input);
+    },
+    async record(input) {
+      await recordCodeChange(getDb(), provider, input);
+    }
+  };
+}
+
 // src/chat/plugins/agent-hooks.ts
 var PluginHookDeniedError = class extends Error {
   constructor(message) {
@@ -2790,7 +2935,29 @@ function getPluginRoutes(options) {
           plugin: pluginName
         })
       },
+      codeChanges: createCodeChangePublisher(pluginName),
       resourceEvents: {
+        async neededMatchKeys(input) {
+          if (!options.resourceEvents.neededMatchKeys) return [];
+          const identifiers = [
+            ...new Set(
+              input.identifiers.map(
+                (identifier) => normalizeResourceEventIdentifier(
+                  plugin.resourceEvents,
+                  identifier
+                )
+              ).filter(Boolean)
+            )
+          ];
+          if (identifiers.length === 0 || input.eventTypes.length === 0) {
+            return [];
+          }
+          return await options.resourceEvents.neededMatchKeys({
+            eventTypes: input.eventTypes,
+            identifiers,
+            namespace: pluginName
+          });
+        },
         async publish(event) {
           const parsed = resourceEventInputSchema.parse(event);
           requirePublishedResourceEvent(plugin, parsed.eventType);
@@ -3438,6 +3605,7 @@ export {
   listResourceEventSubscriptions,
   cancelResourceEventSubscription,
   cancelSubscriptions,
+  collectResourceEventMatchKeys,
   findMatchingResourceEventSubscriptions,
   deliverResourceEventSubscription,
   RESOURCE_SUBSCRIPTION_DEFAULT_TTL_MS,

package/dist/{chunk-3THPTNN6.js → chunk-4RONS3WR.js}

@@ -19,23 +19,23 @@ import {
   releaseConversationWork,
   requestAnotherSlice,
   startConversationWork
-} from "./chunk-TEFNHMO2.js";
+} from "./chunk-Z3QAXJR7.js";
 import {
   ConversationQueueMessageRejectedError
 } from "./chunk-JAL3CH4G.js";
 import {
   getTurnRequestDeadline
-} from "./chunk-UUMBHORH.js";
+} from "./chunk-MLSQX2EX.js";
 import {
   getChatConfig,
   isProviderRetryError
-} from "./chunk-LHQK5XCU.js";
+} from "./chunk-6UDPINOX.js";
 import {
   logException,
   logInfo,
   logWarn,
   withLogContext
-} from "./chunk-UQP54CXZ.js";
+} from "./chunk-3S7ULUWW.js";
 
 // src/chat/task-execution/worker.ts
 var CONVERSATION_WORK_DEFER_DELAY_MS = 15e3;

package/dist/{chunk-LHQK5XCU.js → chunk-6UDPINOX.js}

@@ -3,7 +3,7 @@ import {
   toCanonicalInputMessage,
   toCanonicalOutputMessage,
   toGenAiMessagesTraceAttributes
-} from "./chunk-SVFSYQMT.js";
+} from "./chunk-BHYRYYLY.js";
 import {
   extractGenAiUsageAttributes,
   logException,
@@ -11,7 +11,7 @@ import {
   normalizeGenAiFinishReason,
   serializeGenAiAttribute,
   withSpan
-} from "./chunk-UQP54CXZ.js";
+} from "./chunk-3S7ULUWW.js";
 
 // src/chat/services/provider-error.ts
 var ProviderError = class extends Error {