@sentry/junior 0.194.0 → 0.196.0

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/model-profile.d.ts

@@ -7,9 +7,21 @@ export declare const modelProfileSchema: z.ZodString;
 export type ModelProfile = z.output<typeof modelProfileSchema>;
 /** Runtime configuration for one named model profile. */
 export interface ModelProfileConfig {
+    /**
+     * Tells models which tasks fit this profile.
+     * Name concrete tasks. Add use and avoid cases when helpful.
+     * Do not use model product names as the selection rule.
+     */
+    description?: string;
     modelId: string;
     reasoningLevel?: TurnReasoningLevel;
 }
+/** App-level profile input: a model id string or a full profile config. */
+export type ModelProfileInput = string | ModelProfileConfig;
+/** Format one profile and its task-fit description. */
+export declare function formatModelProfile(profile: ModelProfile, description?: string): string;
+/** Format configured profiles as one list item per line. */
+export declare function formatModelProfiles(profiles: Readonly<Record<string, ModelProfileConfig>>, profileNames: readonly ModelProfile[]): string;
 /** Identify durable profile bindings that the current host cannot resolve. */
 export declare class ModelProfileNotConfiguredError extends Error {
     constructor(profile: ModelProfile);

package/dist/chat/no-reply.d.ts

@@ -1,5 +1,6 @@
 export declare const NO_REPLY_MARKER = "[[NO_REPLY]]";
-/** Detect the reserved marker for intentionally completing without thread text. */
+/**
+ * True when one assistant message ends with the silence marker.
+ * Mid-sentence mentions do not match. Detection is per message only.
+ */
 export declare function isNoReplyMarker(text: string): boolean;
-/** Detect marker leaks before publication strips or rejects them. */
-export declare function containsNoReplyMarker(text: string): boolean;

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/services/subscribed-decision.d.ts

@@ -37,6 +37,14 @@ declare const replyDecisionSchema: z.ZodObject<{
     confidence: z.ZodNumber;
     reason: z.ZodString;
 }, z.core.$strict>;
+/**
+ * Return a stop decision for one message body.
+ * Deferred batches must call this on each body, not on joined text.
+ */
+export declare function getThreadStopDecision(args: {
+    rawText: string;
+    text: string;
+}): SubscribedDecisionResult | undefined;
 /** Fast heuristic check before the LLM classifier — skips messages directed at another party. */
 export declare function getSubscribedReplyPreflightDecision(args: {
     botUserName: string;

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/chat/tools/types.d.ts

@@ -13,9 +13,13 @@ import type { SpawnAgent } from "@/chat/agent/types";
 import type { AttachmentStorage } from "@/chat/attachments/storage";
 import type { Workspace } from "@/chat/workspaces/types";
 import type { ConversationPrivacy } from "@/chat/conversation-privacy";
+interface HandoffProfile {
+    description?: string;
+    name: ModelProfile;
+}
 interface HandoffControl {
-    /** Non-empty catalog of configured targets. */
-    profiles: readonly [ModelProfile, ...ModelProfile[]];
+    /** Non-empty list of configured profiles. */
+    profiles: readonly [HandoffProfile, ...HandoffProfile[]];
     execute: (profile: ModelProfile, options: {
         signal?: AbortSignal;
         toolCallId: string;

package/dist/{chunk-U76RWMFR.js → chunk-5XSEOJPC.js}

@@ -1,13 +1,14 @@
 import {
+  TURN_REASONING_LEVELS,
   modelProfileSchema,
   parseTurnReasoningLevel
-} from "./chunk-D4YV5TDV.js";
+} from "./chunk-NHJU2ZAL.js";
 import {
   getCurrentConversationPrivacy,
   toCanonicalInputMessage,
   toCanonicalOutputMessage,
   toGenAiMessagesTraceAttributes
-} from "./chunk-JOI3DHML.js";
+} from "./chunk-ES7KCEND.js";
 import {
   extractGenAiUsageAttributes,
   logException,
@@ -15,7 +16,7 @@ import {
   normalizeGenAiFinishReason,
   serializeGenAiAttribute,
   withSpan
-} from "./chunk-X76JVHQ4.js";
+} from "./chunk-CTS72G4B.js";
 
 // src/chat/services/provider-error.ts
 var ProviderError = class extends Error {
@@ -675,6 +676,7 @@ var MIN_AGENT_TURN_TIMEOUT_MS = 10 * 1e3;
 var DEFAULT_AGENT_TURN_TIMEOUT_MS = 12 * 60 * 1e3;
 var MAX_SLICES_PER_TURN = 100;
 var MAX_TOOL_CALLS_PER_TURN = 150;
+var MAX_CONSECUTIVE_AUTOMATED_TURNS = 10;
 var DEFAULT_FUNCTION_MAX_DURATION_SECONDS = 300;
 var DEFAULT_SLACK_SLASH_COMMAND = "/jr";
 var DEFAULT_PROCESSING_REACTION_EMOJI = "eyes";
@@ -806,33 +808,103 @@ function validateGatewayModelId(raw) {
 function validateEmbeddingModelId(raw) {
   return toOptionalTrimmed(raw);
 }
+var DEFAULT_STANDARD_PROFILE_DESCRIPTION = "Use for default assistant work: lookups, explanations, ordinary tool use, short answers, and light investigation of one source. Avoid for implementation, debugging, multi-file changes, architecture decisions, or research across several systems.";
+var DEFAULT_HANDOFF_PROFILE_DESCRIPTION = "Use for coding and difficult multi-step work: implementation, debugging, root-cause analysis, broad refactors, multi-file changes, architecture decisions, and research across several systems. Avoid for simple lookups, short answers, single-file reads, or ordinary tool use that the default profile can finish.";
+function parseOptionalProfileDescription(rawDescription, configName, profile) {
+  if (rawDescription === void 0) {
+    return void 0;
+  }
+  if (typeof rawDescription !== "string") {
+    throw new Error(
+      `${configName}.${profile}.description must be a string when set`
+    );
+  }
+  const description = toOptionalTrimmed(rawDescription);
+  if (!description) {
+    throw new Error(
+      `${configName}.${profile}.description must not be empty when set`
+    );
+  }
+  return description;
+}
+function parseOptionalProfileReasoningLevel(rawReasoningLevel, configName, profile) {
+  if (rawReasoningLevel === void 0) {
+    return void 0;
+  }
+  try {
+    return parseTurnReasoningLevel(rawReasoningLevel);
+  } catch {
+    throw new Error(
+      `${configName}.${profile}.reasoningLevel must be one of ${TURN_REASONING_LEVELS.join(", ")}`
+    );
+  }
+}
+function parseProfileConfig(rawProfile, configName, profile) {
+  if (typeof rawProfile === "string") {
+    const modelId2 = validateGatewayModelId(rawProfile);
+    if (!modelId2) {
+      throw new Error(`${configName}.${profile} must not be empty`);
+    }
+    return { modelId: modelId2 };
+  }
+  if (!rawProfile || typeof rawProfile !== "object" || Array.isArray(rawProfile)) {
+    throw new Error(
+      `${configName}.${profile} must be a model id string or an object with modelId`
+    );
+  }
+  const rawModelId = rawProfile.modelId;
+  if (typeof rawModelId !== "string") {
+    throw new Error(
+      `${configName}.${profile}.modelId must be a model id string`
+    );
+  }
+  const modelId = validateGatewayModelId(rawModelId);
+  if (!modelId) {
+    throw new Error(`${configName}.${profile}.modelId must not be empty`);
+  }
+  const description = parseOptionalProfileDescription(
+    rawProfile.description,
+    configName,
+    profile
+  );
+  const reasoningLevel = parseOptionalProfileReasoningLevel(
+    rawProfile.reasoningLevel,
+    configName,
+    profile
+  );
+  return {
+    modelId,
+    ...description ? { description } : void 0,
+    ...reasoningLevel ? { reasoningLevel } : void 0
+  };
+}
 function parseProfileMap(rawProfiles, configName) {
   if (!rawProfiles || typeof rawProfiles !== "object" || Array.isArray(rawProfiles)) {
     const objectType = configName === "AI_MODEL_PROFILES" ? "a JSON object" : "an object";
     throw new Error(`${configName} must be ${objectType}`);
   }
   const profiles = {};
-  for (const [profile, rawModelId] of Object.entries(rawProfiles)) {
+  for (const [profile, rawProfile] of Object.entries(rawProfiles)) {
     if (!modelProfileSchema.safeParse(profile).success) {
       throw new Error(
         `${configName} profile "${profile}" must match ^[a-z][a-z0-9_-]*$`
       );
     }
-    if (typeof rawModelId !== "string") {
-      throw new Error(`${configName}.${profile} must be a model id string`);
-    }
-    const modelId = validateGatewayModelId(rawModelId);
-    if (!modelId) {
-      throw new Error(`${configName}.${profile} must not be empty`);
-    }
-    profiles[profile] = { modelId };
+    profiles[profile] = parseProfileConfig(rawProfile, configName, profile);
   }
   return profiles;
 }
 function parseProfiles(rawValue, standardModelId, handoffModelId) {
   const profiles = {
-    standard: { modelId: standardModelId },
-    handoff: { modelId: handoffModelId, reasoningLevel: "high" }
+    standard: {
+      modelId: standardModelId,
+      description: DEFAULT_STANDARD_PROFILE_DESCRIPTION
+    },
+    handoff: {
+      modelId: handoffModelId,
+      description: DEFAULT_HANDOFF_PROFILE_DESCRIPTION,
+      reasoningLevel: "high"
+    }
   };
   const trimmed = toOptionalTrimmed(rawValue);
   if (trimmed === void 0) {
@@ -904,6 +976,7 @@ function readBotConfig(env, functionMaxDurationSeconds) {
     visionModelId: validateGatewayModelId(env.AI_VISION_MODEL),
     maxSlicesPerTurn: MAX_SLICES_PER_TURN,
     maxToolCallsPerTurn: MAX_TOOL_CALLS_PER_TURN,
+    maxConsecutiveAutomatedTurns: MAX_CONSECUTIVE_AUTOMATED_TURNS,
     turnTimeoutMs: parseAgentTurnTimeoutMs(
       env.AGENT_TURN_TIMEOUT_MS,
       maxTurnTimeoutMs

package/dist/{chunk-OEQOAONV.js → chunk-6LQNW2CJ.js}

@@ -7,7 +7,7 @@ import {
   authenticationUnlinkedEvent,
   fallbackShortTitle,
   generateShortTitle
-} from "./chunk-RFE7DCZK.js";
+} from "./chunk-B5WJBVHY.js";
 import {
   bindProviderConversation,
   createSqlConversationEventStore,
@@ -16,31 +16,31 @@ import {
   getSqlExecutor,
   sanitizePostgresJson,
   withConversationEventLock
-} from "./chunk-ADEACKAH.js";
+} from "./chunk-XNXKRWWI.js";
 import {
   SANDBOX_REPOS_ROOT,
   SANDBOX_WORKSPACE_ROOT,
   sleep
-} from "./chunk-7ANA7PBB.js";
+} from "./chunk-SR5FS2JP.js";
 import {
   MUTATION_LOCK_TTL_MS,
   fenceLock,
   getStateAdapter,
   withLock
-} from "./chunk-V4HXV5MY.js";
+} from "./chunk-EQBHN4JK.js";
 import {
   agentHistoryItemSchema,
   contextProvenance,
   instructionActors,
   instructionProvenanceFor
-} from "./chunk-GFBR4S3Q.js";
+} from "./chunk-7NL7T6VU.js";
 import {
   botConfig,
   completeText,
   escapeXml,
   resolveGatewayModel,
   unwrapCurrentInstruction
-} from "./chunk-U76RWMFR.js";
+} from "./chunk-5XSEOJPC.js";
 import {
   parseSlackMessageTs,
   toStoredSlackActor
@@ -51,7 +51,7 @@ import {
   logException,
   logWarn,
   setSpanAttributes
-} from "./chunk-X76JVHQ4.js";
+} from "./chunk-CTS72G4B.js";
 
 // src/chat/turn-context-tag.ts
 var TURN_CONTEXT_TAG = "runtime-turn-context";

package/dist/{chunk-GFBR4S3Q.js → chunk-7NL7T6VU.js}

@@ -1,7 +1,7 @@
 import {
   TURN_REASONING_LEVELS,
   modelProfileSchema
-} from "./chunk-D4YV5TDV.js";
+} from "./chunk-NHJU2ZAL.js";
 
 // src/chat/conversations/provenance.ts
 import { actorSchema } from "@sentry/junior-plugin-api";

package/dist/{chunk-CFGBKPWQ.js → chunk-7TUDDW3Y.js}

@@ -1,6 +1,6 @@
 import {
   runWithTurnRequestDeadline
-} from "./chunk-NWWDFHXP.js";
+} from "./chunk-VRHZXY5X.js";
 import {
   QUEUE_SIGNATURE_MAX_AGE_MS,
   createVercelQueueClient,
@@ -9,7 +9,7 @@ import {
 } from "./chunk-7H2VZTWN.js";
 import {
   logWarn
-} from "./chunk-X76JVHQ4.js";
+} from "./chunk-CTS72G4B.js";
 
 // src/chat/plugins/task-queue.ts
 import { createHash } from "crypto";
@@ -129,7 +129,7 @@ function pluginTaskCallback() {
     onRejected: logPluginTaskQueueMessageRejected,
     // Load the runner on first use so this module can send without a cycle.
     run: async (message) => {
-      const { processPluginTask } = await import("./task-runner-OQLRHADB.js");
+      const { processPluginTask } = await import("./task-runner-SMUQ5464.js");
       await processPluginTask(message);
     },
     topic: PLUGIN_TASK_QUEUE_TOPIC,

package/dist/{chunk-RFE7DCZK.js → chunk-B5WJBVHY.js}

@@ -3,10 +3,10 @@ import {
 } from "./chunk-PDO5BLNM.js";
 import {
   botConfig
-} from "./chunk-U76RWMFR.js";
+} from "./chunk-5XSEOJPC.js";
 import {
   logWarn
-} from "./chunk-X76JVHQ4.js";
+} from "./chunk-CTS72G4B.js";
 
 // src/chat/conversations/structured-events.ts
 import {

package/dist/{chunk-S7GX44BU.js → chunk-BXIVMNLR.js}

@@ -12,7 +12,7 @@ import {
   logInfo,
   logWarn,
   setSpanAttributes
-} from "./chunk-X76JVHQ4.js";
+} from "./chunk-CTS72G4B.js";
 
 // src/chat/plugins/manifest.ts
 import { z } from "zod";

package/dist/{chunk-QMEF4Z7R.js → chunk-CNI74T7U.js}

@@ -7,23 +7,23 @@ import {
 import {
   formatProviderLabel,
   startOAuthFlow
-} from "./chunk-ENWIHU54.js";
+} from "./chunk-RFNMWONZ.js";
 import {
   abandonReplacedPendingAuth,
   canReusePendingAuthLink
-} from "./chunk-G35QGPO2.js";
+} from "./chunk-DFWJJOW3.js";
 import {
   recordAuthorizationRequested
-} from "./chunk-OEQOAONV.js";
+} from "./chunk-6LQNW2CJ.js";
 import {
   AGENT_INVOCATION_MAILBOX_STATUSES
-} from "./chunk-XLWZRHX5.js";
+} from "./chunk-PIZJBSGZ.js";
 import {
   TURN_REASONING_LEVELS
-} from "./chunk-D4YV5TDV.js";
+} from "./chunk-NHJU2ZAL.js";
 import {
   pluginCatalogRuntime
-} from "./chunk-WWXJUURQ.js";
+} from "./chunk-G6YRPYDC.js";
 import {
   credentialContextSchema
 } from "./chunk-CEMMLV5L.js";

package/dist/{chunk-X76JVHQ4.js → chunk-CTS72G4B.js}

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

package/dist/{chunk-G35QGPO2.js → chunk-DFWJJOW3.js}

@@ -1,7 +1,7 @@
 import {
   abandonTurnRecord,
   extractAssistantText
-} from "./chunk-OEQOAONV.js";
+} from "./chunk-6LQNW2CJ.js";
 import {
   buildDeterministicTurnId
 } from "./chunk-DA2KGZZI.js";
@@ -83,10 +83,7 @@ function markTurnFailed(args) {
 // src/chat/no-reply.ts
 var NO_REPLY_MARKER = "[[NO_REPLY]]";
 function isNoReplyMarker(text) {
-  return text.trim() === NO_REPLY_MARKER;
-}
-function containsNoReplyMarker(text) {
-  return text.includes(NO_REPLY_MARKER);
+  return text.trimEnd().endsWith(NO_REPLY_MARKER);
 }
 
 // src/chat/services/assistant-reply.ts
@@ -198,7 +195,6 @@ export {
   markTurnFailed,
   NO_REPLY_MARKER,
   isNoReplyMarker,
-  containsNoReplyMarker,
   sanitizeAssistantText,
   decideReply,
   getAssistantReplyText,