@sentry/junior 0.194.0 → 0.195.0

package/dist/app.js

@@ -1,15 +1,15 @@
 import {
   processConversationWork
-} from "./chunk-73JEAQRT.js";
+} from "./chunk-HE5PZAPS.js";
 import {
   bindSpawnAgent
-} from "./chunk-XRDSML3K.js";
+} from "./chunk-QHJZSYKY.js";
 import {
   createAgentInvocationWorker,
   enqueueAgentInvocation,
   listPendingAgentInvocationMailboxAppends,
   resolveAgentInvocationId
-} from "./chunk-F2KSURTJ.js";
+} from "./chunk-N67T4VY3.js";
 import {
   GET as GET2,
   GET2 as GET3,
@@ -37,12 +37,12 @@ import {
   startProcessingReaction,
   stripLeadingBotMention,
   wakePausedTurn
-} from "./chunk-INTBMGNX.js";
+} from "./chunk-7UED4D5T.js";
 import "./chunk-FA6POGLH.js";
 import {
   AgentRunError,
   executeTurn
-} from "./chunk-53IEEFFP.js";
+} from "./chunk-CE2P6TOV.js";
 import {
   buildDeliveredTurnStatePatch,
   completeAuthPauseTurn,
@@ -53,7 +53,7 @@ import {
   getTurnUserSlackMessageTs,
   persistAuthPauseTurnState,
   requireTurnFailureEventId
-} from "./chunk-2NL3Y47F.js";
+} from "./chunk-KUQRWV53.js";
 import {
   claimDispatchMailboxAppend,
   confirmDispatchMailboxAppend,
@@ -73,11 +73,11 @@ import {
   processPluginTask,
   resolveTurnSessionRouting,
   scheduleSessionCompletedPluginTasks
-} from "./chunk-NPO24LAN.js";
+} from "./chunk-BJZML4RT.js";
 import {
   ConversationTurnLifecycleService,
   getTurnLifecycle
-} from "./chunk-6H2MKVV5.js";
+} from "./chunk-7PQMTME5.js";
 import {
   coerceThreadConversationState,
   getLocationConfigurationService,
@@ -86,7 +86,7 @@ import {
   persistThreadRuntimeState,
   persistThreadState,
   persistThreadStateById
-} from "./chunk-GY5SEFVL.js";
+} from "./chunk-FE3Y4KES.js";
 import {
   GET,
   appendAndEnqueueWebMessage,
@@ -101,24 +101,24 @@ import {
   resolveSlackChannelTypeFromMessage,
   resolveSlackConversationContext,
   webActorFromEmail
-} from "./chunk-H4DCWLTR.js";
+} from "./chunk-PYTRZZ4V.js";
 import {
   createWebAuthorization,
   deleteWebAuthorization
-} from "./chunk-XND3J6AT.js";
+} from "./chunk-5HNXLP4W.js";
 import {
   recordTaskExecution
-} from "./chunk-VOB2DKO6.js";
+} from "./chunk-5NR7N567.js";
 import "./chunk-RC745GGZ.js";
 import {
   createVercelPluginTaskCallback,
   queueCallback,
   registerVercelPluginTaskDevConsumer
-} from "./chunk-CFGBKPWQ.js";
+} from "./chunk-6GGDBXXP.js";
 import {
   validatePluginEgressCredentialHooks,
   validatePluginRegistrations
-} from "./chunk-KNIAWMBU.js";
+} from "./chunk-3VWIZVK7.js";
 import {
   defineJuniorPlugins,
   pluginCatalogConfigFromEnv,
@@ -129,6 +129,7 @@ import {
   RESOURCE_EVENT_MESSAGE_AUTHOR,
   RESOURCE_EVENT_SYSTEM_ACTOR,
   SANDBOX_EGRESS_PROXY_PATH,
+  admitAutomatedTurn,
   buildSteeringPiMessage,
   clearSandboxEgressSignals,
   consumeSandboxEgressAuthRequiredSignal,
@@ -144,11 +145,14 @@ import {
   latestReportedProgress,
   listThreadReplies,
   logScheduledTaskRunSkipped,
+  maybePostAutomatedTurnLimitNotice,
   normalizeSandboxEgressTracePropagationDomains,
   parseSandboxEgressCredentialToken,
+  postAutomatedTurnLimitNoticeForDestination,
   processWorkspaceSnapshotJob,
   publicArtifactHeaders,
   readPublicArtifact,
+  recordFinishedTurnForAutomatedLimit,
   renderAttachmentText,
   renderBlockText,
   renderTaskInput,
@@ -158,11 +162,11 @@ import {
   shouldEmitDevAgentTrace,
   shouldPropagateSandboxEgressTrace,
   unpublishedArtifactHeaders
-} from "./chunk-G4RARFNT.js";
+} from "./chunk-FEZIEEOP.js";
 import {
   AuthorizationFlowDisabledError,
   PluginCredentialFailureError
-} from "./chunk-QMEF4Z7R.js";
+} from "./chunk-JBSCMOLR.js";
 import "./chunk-6Y5B5PEX.js";
 import "./chunk-DIB4GX3G.js";
 import {
@@ -170,14 +174,14 @@ import {
   deleteMcpAuthSessionsForUserProvider,
   deleteMcpServerSessionId,
   deleteMcpStoredOAuthCredentials
-} from "./chunk-AWZS5SVX.js";
+} from "./chunk-OQHO62VA.js";
 import {
   RetryableDeliveryError,
   createAgentRunner,
   formatProviderLabel,
   postSlackMessage,
   startOAuthFlow
-} from "./chunk-ENWIHU54.js";
+} from "./chunk-R5OHONYU.js";
 import {
   ConversationTurnBoundaryError,
   CooperativeTurnYieldError,
@@ -193,7 +197,7 @@ import {
   markTurnCompleted,
   markTurnFailed,
   startActiveTurn
-} from "./chunk-G35QGPO2.js";
+} from "./chunk-VYDIA2UL.js";
 import {
   abandonTurnRecord,
   appendThreadContextMessages,
@@ -230,7 +234,7 @@ import {
   trimTrailingAssistantMessages,
   turnHasReply,
   upsertConversationMessage
-} from "./chunk-OEQOAONV.js";
+} from "./chunk-RZ3PBNDV.js";
 import {
   getExperimentalFeatures,
   isExperimentalFeatureEnabled,
@@ -250,10 +254,10 @@ import {
   scheduledRunId,
   scheduledRunSchema,
   withScheduledTaskLock
-} from "./chunk-WMJS5DDV.js";
+} from "./chunk-DTYOEHUP.js";
 import {
   parseSlackThreadId
-} from "./chunk-IOGDKPVU.js";
+} from "./chunk-6TRQLG3D.js";
 import {
   CONVERSATION_WORK_STALE_ENQUEUE_MS,
   appendAndEnqueueInboundMessage,
@@ -268,16 +272,16 @@ import {
   removeActiveConversation,
   requestConversationWork,
   stopConversationWork
-} from "./chunk-E53C73ML.js";
+} from "./chunk-QKHZF2LH.js";
 import {
   buildDeterministicAssistantMessageId,
   buildDeterministicTurnId
 } from "./chunk-DA2KGZZI.js";
-import "./chunk-RFE7DCZK.js";
+import "./chunk-R5BGW4WR.js";
 import {
   getSandboxResourceConfig,
   setSandboxResourceConfig
-} from "./chunk-ELCYG6UU.js";
+} from "./chunk-L62JVQPL.js";
 import "./chunk-PDO5BLNM.js";
 import "./chunk-UIE3R5XU.js";
 import {
@@ -286,7 +290,7 @@ import {
 } from "./chunk-X6GDDWQH.js";
 import {
   getTurnRequestDeadline
-} from "./chunk-NWWDFHXP.js";
+} from "./chunk-I4RH3KLJ.js";
 import {
   getVercelConversationWorkQueue,
   resolveConversationWorkQueueTopic,
@@ -322,7 +326,7 @@ import {
   verifyEventTaskCredentialSubject,
   verifyScheduledTaskCredentialSubject,
   verifySlackDirectCredentialSubject
-} from "./chunk-CCTYK5RH.js";
+} from "./chunk-PFQRZ4IB.js";
 import "./chunk-3Y47VMHV.js";
 import {
   createSlackDestination,
@@ -334,7 +338,7 @@ import {
   requireSlackDestination,
   withConversationEventLock,
   withConversationMutationLock
-} from "./chunk-ADEACKAH.js";
+} from "./chunk-KQ3GZGBK.js";
 import {
   juniorAgentBindings,
   juniorAgentInvocations,
@@ -342,13 +346,13 @@ import {
   juniorConversations,
   juniorSchedulerRuns,
   juniorSchedulerTasks
-} from "./chunk-XLWZRHX5.js";
-import "./chunk-7ANA7PBB.js";
+} from "./chunk-FPQPYJEG.js";
+import "./chunk-LM7UE523.js";
 import {
   acquireActiveLock,
   getStateAdapter,
   withActiveLock
-} from "./chunk-V4HXV5MY.js";
+} from "./chunk-7MYXH5LA.js";
 import {
   instructionProvenanceFor
 } from "./chunk-GFBR4S3Q.js";
@@ -370,17 +374,17 @@ import {
   isProviderRetryError,
   setProfiles,
   setSlackReactionConfig
-} from "./chunk-U76RWMFR.js";
+} from "./chunk-LMYRF6HX.js";
 import {
   defaultModelId,
   modelIdForProfile
 } from "./chunk-D4YV5TDV.js";
-import "./chunk-JOI3DHML.js";
-import "./chunk-P2P6MUQ4.js";
+import "./chunk-KBPWC7NU.js";
+import "./chunk-RQO67SAO.js";
 import {
   pluginCatalogRuntime
-} from "./chunk-WWXJUURQ.js";
-import "./chunk-S7GX44BU.js";
+} from "./chunk-RKA22BQP.js";
+import "./chunk-X3PBQ4BK.js";
 import {
   credentialContextForActor
 } from "./chunk-CEMMLV5L.js";
@@ -416,13 +420,13 @@ import {
   withContext,
   withLogContext,
   withSpan
-} from "./chunk-X76JVHQ4.js";
+} from "./chunk-HUQOXMDG.js";
 import {
   continueTrace
 } from "./chunk-PEQXYSSE.js";
 import {
   JUNIOR_VERSION
-} from "./chunk-IME5OW4Y.js";
+} from "./chunk-C4NY6L7S.js";
 
 // src/app.ts
 import { createRequire } from "module";
@@ -7251,6 +7255,21 @@ function createSlackTurn(deps) {
                 })
               );
               await persistThreadRuntimeStateWithRetry(thread, completedState);
+              const automatedTurnLimit = await recordFinishedTurnForAutomatedLimit(
+                {
+                  conversationId,
+                  destination,
+                  maxTurns: botConfig.maxConsecutiveAutomatedTurns,
+                  source
+                }
+              );
+              await maybePostAutomatedTurnLimitNotice({
+                conversationId,
+                destination,
+                maxTurns: botConfig.maxConsecutiveAutomatedTurns,
+                threadTs,
+                update: automatedTurnLimit
+              });
             } catch (saveError) {
               saveFailed = true;
               saveFailureEventId = logException(
@@ -9141,6 +9160,19 @@ function createConversationTurnWorker(agentRunner, deliverMessage) {
                   surface
                 });
               }
+              const automatedTurnLimit = await recordFinishedTurnForAutomatedLimit({
+                conversationId: context.conversationId,
+                destination,
+                maxTurns: botConfig.maxConsecutiveAutomatedTurns,
+                source
+              });
+              await maybePostAutomatedTurnLimitNotice({
+                conversationId: context.conversationId,
+                destination,
+                maxTurns: botConfig.maxConsecutiveAutomatedTurns,
+                threadTs: conversationLocation?.provider === "slack" ? conversationLocation.threadTs : void 0,
+                update: automatedTurnLimit
+              });
               completedSuccessfully = reply.diagnostics.outcome === "success";
               return completedSuccessfully ? {
                 outcome: assistantMessageDelivered ? "success" : "no_reply"
@@ -9523,8 +9555,40 @@ async function ingestEventTasks(input, options) {
   const tasks = await findMatchingEventTasks(db, event, options.teamId);
   let dispatched = 0;
   const errors = [];
+  const maxTurns = botConfig.maxConsecutiveAutomatedTurns;
+  const noticedDestinations = /* @__PURE__ */ new Set();
   for (const task of tasks) {
     try {
+      const decision = await admitAutomatedTurn({
+        maxTurns,
+        nowMs,
+        scope: { kind: "destination", destination: task.destination }
+      });
+      if (decision.status === "paused") {
+        const destinationId = `${task.destination.teamId}:${task.destination.channelId}`;
+        logInfo("event_tasks.automated_turn_limit.paused", {
+          "app.automated_turn_limit.consecutive": decision.consecutiveAutomatedTurns,
+          "app.automated_turn_limit.max": maxTurns,
+          "app.event_task.id": task.id,
+          "app.resource_event.event_type": event.eventType,
+          "app.resource_event.namespace": event.namespace,
+          "app.slack.channel_id": task.destination.channelId,
+          "app.slack.team_id": task.destination.teamId
+        });
+        if (decision.shouldPostNotice && !noticedDestinations.has(destinationId)) {
+          const posted = await postAutomatedTurnLimitNoticeForDestination({
+            destination: task.destination,
+            maxTurns,
+            nowMs,
+            resumeIn: "channel",
+            scope: { kind: "destination", destination: task.destination }
+          });
+          if (posted) {
+            noticedDestinations.add(destinationId);
+          }
+        }
+        continue;
+      }
       const idempotencyKey = eventTaskDispatchKey(
         task.id,
         event.namespace,

package/dist/{catalog-runtime-MICXEBLK.js → catalog-runtime-6E6SGRZK.js}

@@ -1,14 +1,14 @@
 import {
   pluginCatalogRuntime
-} from "./chunk-WWXJUURQ.js";
-import "./chunk-S7GX44BU.js";
+} from "./chunk-RKA22BQP.js";
+import "./chunk-X3PBQ4BK.js";
 import "./chunk-CEMMLV5L.js";
 import "./chunk-N7TMSOZH.js";
 import "./chunk-DWPN6SCH.js";
 import "./chunk-TXKUKMVO.js";
-import "./chunk-X76JVHQ4.js";
+import "./chunk-HUQOXMDG.js";
 import "./chunk-PEQXYSSE.js";
-import "./chunk-IME5OW4Y.js";
+import "./chunk-C4NY6L7S.js";
 export {
   pluginCatalogRuntime
 };

package/dist/chat/config.d.ts

@@ -22,6 +22,7 @@ export interface BotConfig {
     visionModelId?: string;
     maxSlicesPerTurn: number;
     maxToolCallsPerTurn: number;
+    maxConsecutiveAutomatedTurns: number;
     turnTimeoutMs: number;
     userName: string;
     webSearchModelId: string;

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

@@ -1,24 +1,34 @@
 import { type ResourceEvent, type User } from "@sentry/junior-plugin-api";
 import type { JuniorDatabase } from "@/db/db";
+import { type EventTaskStatus } from "@/db/schema/event-tasks";
 import { type EventTask } from "./types";
-/** Read one event task by id. */
-export declare function getEventTask(db: JuniorDatabase, id: string): Promise<EventTask | undefined>;
-/** Create one retry-stable event task or return its existing record. */
-export declare function createEventTask(db: JuniorDatabase, task: EventTask): Promise<EventTask>;
-/** Replace an existing event task. */
-export declare function saveEventTask(db: JuniorDatabase, task: EventTask): Promise<EventTask | undefined>;
-/** Delete one existing event task. */
-export declare function deleteEventTask(db: JuniorDatabase, id: string): Promise<EventTask | undefined>;
-/** List event tasks in one Slack workspace. */
-export declare function listEventTasksForTeam(db: JuniorDatabase, teamId: string): Promise<EventTask[]>;
+/** Live event task plus retained SQL status for history after delete. */
+export type StoredEventTask = EventTask & {
+    status: EventTaskStatus;
+};
+/** Read one event task by id, including deleted rows when present. */
+export declare function getEventTask(db: JuniorDatabase, id: string): Promise<StoredEventTask | undefined>;
+/** Create one retry-stable event task, or revive a deleted row with the new payload. */
+export declare function createEventTask(db: JuniorDatabase, task: EventTask): Promise<StoredEventTask>;
+/** Replace an existing non-deleted event task. */
+export declare function saveEventTask(db: JuniorDatabase, task: EventTask): Promise<StoredEventTask | undefined>;
+/** Mark one existing event task deleted while retaining the row for history. */
+export declare function deleteEventTask(db: JuniorDatabase, id: string): Promise<StoredEventTask | undefined>;
+/** List live event tasks in one Slack workspace. */
+export declare function listEventTasksForTeam(db: JuniorDatabase, teamId: string): Promise<StoredEventTask[]>;
 /** Return whether one event task was created by a viewer-linked Slack identity. */
 export declare function eventTaskBelongsToUser(task: EventTask, user: User): boolean;
-/** List a bounded newest-first page of event tasks created by one user. */
-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[]>;
+/** List a bounded newest-first page of live event tasks created by one user. */
+export declare function listEventTasksCreatedBy(db: JuniorDatabase, user: User, limit: number): Promise<StoredEventTask[]>;
 /**
- * Collect match keys from event tasks for these identifiers and event types.
+ * List deleted event tasks created by one user, newest first.
+ * Used only to keep historical runs after the live task list drops the row.
+ */
+export declare function listDeletedEventTasksCreatedBy(db: JuniorDatabase, user: User, limit: number): Promise<StoredEventTask[]>;
+/** List live event tasks whose current Slack destination is public. */
+export declare function listPublicEventTasksForTeams(db: JuniorDatabase, teamIds: string[], limit: number): Promise<StoredEventTask[]>;
+/**
+ * Collect match keys from live 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: {
@@ -27,5 +37,5 @@ export declare function collectEventTaskMatchKeys(db: JuniorDatabase, input: {
     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[]>;
+/** Find every live task matching one normalized resource event. */
+export declare function findMatchingEventTasks(db: JuniorDatabase, event: ResourceEvent, teamId: string): Promise<StoredEventTask[]>;

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

@@ -43,7 +43,8 @@ export declare function createResourceEventInboundMessage(input: {
  * Enqueue a resource event as normal conversation mailbox input.
  *
  * The watch only names the conversation. Destination stays on the conversation
- * and is applied when the worker runs.
+ * and is applied when the worker runs. After too many automated Turns with no
+ * user Turn, later wakes stay quiet until a user message clears the pause.
  */
 export declare function enqueueResourceEventNotification(args: {
     event: ResourceEventNotification;

package/dist/chat/services/automated-turn-limit.d.ts

@@ -0,0 +1,110 @@
+/**
+ * Stops event wakes after too many automated Turns with no user Turn.
+ *
+ * Resource-event watches count on the Conversation. Event tasks and other
+ * agent dispatches count on the Slack Destination. A finished user Turn clears
+ * every scope that Turn can name.
+ */
+import type { Destination, Source } from "@sentry/junior-plugin-api";
+import type { StateAdapter } from "chat";
+import { z } from "zod";
+/** Stored consecutive-turn limit for one Conversation or Destination. */
+declare const automatedTurnLimitStateSchema: z.ZodObject<{
+    consecutiveAutomatedTurns: z.ZodNumber;
+    noticePostedAtMs: z.ZodOptional<z.ZodNumber>;
+    paused: z.ZodBoolean;
+    updatedAtMs: z.ZodNumber;
+}, z.core.$strict>;
+export type AutomatedTurnLimitState = z.output<typeof automatedTurnLimitStateSchema>;
+export type AutomatedTurnLimitScope = {
+    kind: "conversation";
+    conversationId: string;
+} | {
+    kind: "destination";
+    destination: Destination;
+};
+export type AutomatedTurnLimitDecision = {
+    status: "allow";
+    consecutiveAutomatedTurns: number;
+} | {
+    status: "paused";
+    consecutiveAutomatedTurns: number;
+    shouldPostNotice: boolean;
+};
+export type AutomatedTurnLimitUpdate = {
+    consecutiveAutomatedTurns: number;
+    paused: boolean;
+    shouldPostNotice: boolean;
+    /** Where the pause notice should tell the user to reply. */
+    resumeIn: "thread" | "channel";
+};
+/** True when this Source starts an automated Turn rather than a user Turn. */
+export declare function isAutomatedTurnSource(source: Source | undefined): boolean;
+/**
+ * Scope that counts automated Turns for this Source.
+ * Resource-event watches stay on the Conversation. Dispatches use Destination.
+ */
+export declare function automatedTurnLimitScopeForSource(args: {
+    conversationId: string;
+    destination?: Destination;
+    source?: Source;
+}): AutomatedTurnLimitScope | undefined;
+/** Plain notice when automatic updates stop until the user replies. */
+export declare function buildAutomatedTurnLimitResponse(args: {
+    maxTurns: number;
+    resumeIn?: "thread" | "channel";
+}): string;
+/** Read the current consecutive-turn limit for one scope. */
+export declare function getAutomatedTurnLimitState(args: {
+    nowMs?: number;
+    scope: AutomatedTurnLimitScope;
+    state?: StateAdapter;
+}): Promise<AutomatedTurnLimitState>;
+/**
+ * Allow one automated wake, or refuse once the consecutive-turn limit is full.
+ * If a prior pause never posted its notice, claim the notice slot so one caller
+ * posts it. Clear the claim if that post fails or is skipped.
+ */
+export declare function admitAutomatedTurn(args: {
+    maxTurns: number;
+    nowMs?: number;
+    scope: AutomatedTurnLimitScope;
+    state?: StateAdapter;
+}): Promise<AutomatedTurnLimitDecision>;
+/** Count one finished automated Turn toward the consecutive-turn limit. */
+export declare function countAutomatedTurn(args: {
+    maxTurns: number;
+    nowMs?: number;
+    scope: AutomatedTurnLimitScope;
+    state?: StateAdapter;
+}): Promise<AutomatedTurnLimitUpdate>;
+/**
+ * Drop a failed notice claim so a later paused wake can post the notice.
+ * Keeps the pause and consecutive count.
+ */
+export declare function clearAutomatedTurnLimitNoticeClaim(args: {
+    nowMs?: number;
+    scope: AutomatedTurnLimitScope;
+    state?: StateAdapter;
+}): Promise<void>;
+/** Clear the consecutive automated-turn count after a user-owned Turn. */
+export declare function resetAutomatedTurnLimit(args: {
+    nowMs?: number;
+    scope: AutomatedTurnLimitScope;
+    state?: StateAdapter;
+}): Promise<void>;
+/**
+ * Update consecutive automated-turn limits after one finished Turn.
+ *
+ * Automated Turns count one matching scope. User Turns clear Conversation and
+ * Destination scopes so later event wakes can run again.
+ */
+export declare function recordFinishedTurnForAutomatedLimit(args: {
+    conversationId: string;
+    destination?: Destination;
+    maxTurns: number;
+    nowMs?: number;
+    source?: Source;
+    state?: StateAdapter;
+}): Promise<AutomatedTurnLimitUpdate | undefined>;
+export {};

package/dist/chat/slack/automated-turn-limit-notice.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Destination-visible pause notice for the consecutive automated-turn limit.
+ *
+ * Best-effort: a failed post must not fail the Turn or re-enable event wakes.
+ * The consecutive-turn limit claims the notice slot before this post. Clear that
+ * claim when the post fails or is skipped so a later paused wake can try again.
+ */
+import type { Destination } from "@sentry/junior-plugin-api";
+import { type AutomatedTurnLimitScope, type AutomatedTurnLimitUpdate } from "@/chat/services/automated-turn-limit";
+/** Post the pause notice for one Conversation Location when known. */
+export declare function postAutomatedTurnLimitNoticeForConversation(args: {
+    conversationId: string;
+    maxTurns: number;
+    nowMs?: number;
+    resumeIn?: "thread" | "channel";
+    scope?: AutomatedTurnLimitScope;
+}): Promise<boolean>;
+/** Post the pause notice for one Slack Destination. */
+export declare function postAutomatedTurnLimitNoticeForDestination(args: {
+    destination: Destination;
+    maxTurns: number;
+    nowMs?: number;
+    resumeIn?: "thread" | "channel";
+    scope?: AutomatedTurnLimitScope;
+    threadTs?: string;
+}): Promise<boolean>;
+/**
+ * Post the pause notice after a finished Turn hits the limit.
+ * Prefer the Conversation Location so thread watches stay in-thread.
+ */
+export declare function maybePostAutomatedTurnLimitNotice(args: {
+    conversationId: string;
+    destination?: Destination;
+    maxTurns: number;
+    nowMs?: number;
+    threadTs?: string;
+    update: AutomatedTurnLimitUpdate | undefined;
+}): Promise<void>;

package/dist/chat/tasks/execution-stats.d.ts

@@ -79,9 +79,10 @@ export declare function readTaskExecutions(args: {
 }): Promise<TaskExecutionRecord[]>;
 /** Load newest-first executions for the supplied viewer-visible tasks. */
 export declare function readTaskRuns(args: {
+    conversationIds?: string[];
     limit: number;
     namespace?: string;
-    tasks: Array<{
+    tasks?: Array<{
         kind: TaskExecutionType;
         taskId: string;
     }>;

package/dist/chat/tasks/read.d.ts

@@ -1,9 +1,12 @@
 import type { User } from "@sentry/junior-plugin-api";
 import type { ConversationSourceTask } from "@/api/schema/conversation";
 import type { TaskExecutionList, TaskList, TaskRunList } from "@/api/schema/task";
-/** Read viewer-owned and public-workspace tasks as one bounded newest-first projection. */
 export declare function readViewerTasks(user: User): Promise<TaskList>;
-/** Read newest runs across the viewer-visible scheduled and event tasks. */
+/**
+ * Read newest runs across live viewer-visible tasks and deleted tasks the
+ * viewer owns. Deleted task rows stay available so history does not depend on
+ * conversation actor membership.
+ */
 export declare function readViewerTaskRuns(user: User): Promise<TaskRunList>;
 export declare class ViewerTaskNotFoundError extends Error {
     constructor();

package/dist/{chunk-KNIAWMBU.js → chunk-3VWIZVK7.js}

@@ -1,6 +1,6 @@
 import {
   pluginCatalogRuntime
-} from "./chunk-WWXJUURQ.js";
+} from "./chunk-RKA22BQP.js";
 
 // src/chat/plugins/validation.ts
 import { isDeepStrictEqual } from "util";

package/dist/{chunk-XND3J6AT.js → chunk-5HNXLP4W.js}

@@ -1,6 +1,6 @@
 import {
   getStateAdapter
-} from "./chunk-V4HXV5MY.js";
+} from "./chunk-7MYXH5LA.js";
 import {
   getClient
 } from "./chunk-PEQXYSSE.js";