@sentry/junior 0.137.0 → 0.139.0

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

@@ -0,0 +1,31 @@
+import type { StateAdapter } from "chat";
+import type { ConversationStore } from "@/chat/conversations/store";
+import type { AgentRunner } from "@/chat/runtime/agent-runner";
+import { type InboundMessage } from "@/chat/task-execution/store";
+import type { ConversationWorkQueue } from "@/chat/task-execution/queue";
+import type { ConversationWorkerContext, ConversationWorkerResult } from "@/chat/task-execution/worker";
+import type { AgentInvocation, CreateAgentInvocationInput } from "./types";
+type EnqueueOptions = {
+    conversationStore?: ConversationStore;
+    nowMs?: number;
+    queue: ConversationWorkQueue;
+    state?: StateAdapter;
+};
+/** Build destinationless mailbox work that references one durable invocation. */
+export declare function buildAgentInvocationInboundMessage(invocation: AgentInvocation, nowMs?: number): InboundMessage;
+/** Append one invocation to its child mailbox and send the normal queue wake. */
+export declare function enqueueAgentInvocation(invocation: AgentInvocation, options: EnqueueOptions): Promise<void>;
+/** Create or replay an invocation, then durably schedule its child work. */
+export declare function createAndEnqueueAgentInvocation(input: CreateAgentInvocationInput, options: EnqueueOptions): Promise<AgentInvocation>;
+/** 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>;
+/** Route invocation-backed work before falling through to existing consumers. */
+export declare function routeAgentInvocationWork(options: {
+    fallbackWorker: (context: ConversationWorkerContext) => Promise<ConversationWorkerResult>;
+    invocationWorker: (context: ConversationWorkerContext, invocationId: string) => Promise<ConversationWorkerResult>;
+}): (context: ConversationWorkerContext) => Promise<ConversationWorkerResult>;
+export {};

package/dist/chat/config.d.ts

@@ -29,6 +29,7 @@ export type SqlDriver = "neon" | "postgres";
 export interface ChatConfig {
     bot: BotConfig;
     functionMaxDurationSeconds: number;
+    conversationWorkEnabled: boolean;
     conversationWorkSoftYieldAfterMs: number;
     sql: {
         databaseUrl: string;

package/dist/chat/conversations/sql/store.d.ts

@@ -5,11 +5,19 @@ import type { JuniorSqlDatabase } from "@/db/db";
 import type { Conversation, ConversationExecution, ConversationSource, ConversationStore } from "../store";
 import type { AgentTurnUsage } from "@/chat/usage";
 import { type ProviderConversationBinding, type ProviderConversationReference } from "./bindings";
+/** Serialize one conversation's durable mutations inside a SQL transaction. */
+export declare function withConversationMutationLock<T>(executor: JuniorSqlDatabase, conversationId: string, callback: () => Promise<T>): Promise<T>;
 export declare class SqlStore implements ConversationStore {
     private readonly executor;
     constructor(executor: JuniorSqlDatabase);
     getConversationIdByProviderConversation(args: ProviderConversationReference): Promise<string | undefined>;
     bindProviderConversation(args: ProviderConversationBinding): Promise<void>;
+    createChild(args: {
+        childConversationId: string;
+        parentConversationId: string;
+        nowMs?: number;
+        source?: ConversationSource;
+    }): Promise<void>;
     get(args: {
         conversationId: string;
     }): Promise<Conversation | undefined>;

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

@@ -49,6 +49,13 @@ export interface Conversation {
 }
 /** Persist and read durable conversation metadata for reporting surfaces. */
 export interface ConversationStore {
+    /** Create one destinationless child with immutable parent lineage. */
+    createChild(args: {
+        childConversationId: string;
+        parentConversationId: string;
+        nowMs?: number;
+        source?: ConversationSource;
+    }): Promise<void>;
     get(args: {
         conversationId: string;
     }): Promise<Conversation | undefined>;

package/dist/chat/credentials/context.d.ts

@@ -1,4 +1,5 @@
 import { z } from "zod";
+import { type Actor } from "@/chat/actor";
 declare const credentialSubjectBindingSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     type: z.ZodLiteral<"slack-direct-conversation">;
     teamId: z.ZodString;
@@ -100,6 +101,19 @@ export type CredentialSubjectBinding = z.output<typeof credentialSubjectBindingS
 export type CredentialSystemActor = z.output<typeof credentialSystemActorSchema>;
 export type CredentialSubject = z.output<typeof credentialSubjectSchema>;
 export type CredentialContext = z.output<typeof credentialContextSchema>;
+/**
+ * Build credential authority from the run actor.
+ *
+ * `actor` is the rich execution principal. This projects the credential stub
+ * tools/auth need from it:
+ * - user actor → `{ actor: { type: "user", userId } }`
+ * - system actor → `{ actor: systemActor, subject? }`
+ *
+ * They only diverge when a system run carries an explicit delegated `subject`
+ * (scheduled/event-task creator credentials). Callers should set `actor` first,
+ * then derive this — do not hand-build parallel shapes.
+ */
+export declare function credentialContextForActor(actor: Actor, subject?: CredentialSubject): CredentialContext;
 /** Return the user whose OAuth token may satisfy this credential request. */
 export declare function credentialUserSubjectId(context: CredentialContext): string | undefined;
 /** Parse an untrusted credential context payload from sandbox egress state. */

package/dist/chat/experimental.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Known unstable product features that must be opted into explicitly.
+ * Add new keys here as features graduate from private experiments; remove them
+ * once they become stable defaults.
+ */
+export declare const EXPERIMENTAL_FEATURES: readonly ["subagents"];
+/** One known experimental feature name. */
+export type ExperimentalFeature = (typeof EXPERIMENTAL_FEATURES)[number];
+/** App-level opt-ins for unstable product features. */
+export type ExperimentalFeaturesConfig = Readonly<Partial<Record<ExperimentalFeature, boolean>>>;
+/** Replace app-level experimental opt-ins and return the previous setting. */
+export declare function setExperimentalFeatures(config?: ExperimentalFeaturesConfig): ExperimentalFeaturesConfig;
+/** Return a copy of the app-level experimental opt-ins configured by createApp(). */
+export declare function getExperimentalFeatures(): ExperimentalFeaturesConfig;
+/** Return whether one experimental feature is enabled via createApp({ experimental }). */
+export declare function isExperimentalFeatureEnabled(feature: ExperimentalFeature): boolean;

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

@@ -0,0 +1,23 @@
+/** Synthetic Slack author id stamped on resource-event mailbox messages. */
+export declare const RESOURCE_EVENT_SLACK_AUTHOR_ID = "UJRNEVENT";
+/** System execution actor for every resource-event turn. */
+export declare const RESOURCE_EVENT_SYSTEM_ACTOR: {
+    readonly platform: "system";
+    readonly name: "resource-event";
+};
+/** Whether a durable conversation message is a resource-event turn input. */
+export declare function isResourceEventConversationMessage(message: {
+    author?: {
+        userId?: string;
+    };
+    meta?: {
+        eventType?: string;
+    };
+}): boolean;
+/**
+ * Whether a Slack Message payload is a synthetic resource-event notification.
+ * Checks the raw `event_type` marker stamped at mailbox serialization.
+ */
+export declare function isResourceEventSlackMessage(message: {
+    raw?: unknown;
+}): boolean;

package/dist/chat/runtime/agent-runner.d.ts

@@ -1,4 +1,4 @@
-import type { AgentRunRequest } from "@/chat/agent/request";
+import { type AgentRunRequest, type SpawnAgent } from "@/chat/agent/request";
 import type { AgentRunOutcome } from "@/chat/runtime/agent-run-outcome";
 import type { SandboxEgressTracePropagationConfig } from "@/chat/sandbox/egress/tracing";
 /** Run one agent-run slice behind runtime-owned orchestration boundaries. */
@@ -7,5 +7,6 @@ export interface AgentRunner {
 }
 /** Adapt the Pi-facing agent-run executor behind the runtime-owned runner seam. */
 export declare function createAgentRunner(run: AgentRunner["run"], options?: {
+    bindSpawnAgent?: (request: AgentRunRequest) => SpawnAgent | undefined;
     tracePropagation?: SandboxEgressTracePropagationConfig;
 }): AgentRunner;

package/dist/chat/services/auth-pause.d.ts

@@ -1,6 +1,5 @@
 export type AuthorizationPauseKind = "mcp" | "plugin";
 export type AuthorizationPauseDisposition = "link_already_sent" | "link_sent";
-export type AuthorizationFlowMode = "interactive" | "disabled";
 /**
  * Runtime-owned signal that the current turn must park until the user
  * completes an external authorization step.

package/dist/chat/services/mcp-auth-orchestration.d.ts

@@ -9,7 +9,7 @@
 import type { OAuthClientProvider } from "@modelcontextprotocol/sdk/client/auth.js";
 import type { Destination, Source } from "@sentry/junior-plugin-api";
 import { type OAuthAuthorization } from "@/chat/oauth-authorization";
-import { AuthorizationPauseError, type AuthorizationFlowMode } from "@/chat/services/auth-pause";
+import { AuthorizationPauseError } from "@/chat/services/auth-pause";
 import type { ThreadArtifactsState } from "@/chat/state/artifacts";
 import type { ConversationPendingAuthState } from "@/chat/state/conversation";
 import type { PluginDefinition } from "@/chat/plugins/types";
@@ -32,7 +32,8 @@ export interface McpAuthOrchestrationInput {
     getArtifactState: () => ThreadArtifactsState | undefined;
     getMergedArtifactState: () => ThreadArtifactsState;
     recordPendingAuth?: (pendingAuth: ConversationPendingAuthState | undefined) => void | Promise<void>;
-    authorizationFlowMode?: AuthorizationFlowMode;
+    /** When false, required auth hard-fails instead of pausing for an OAuth link. */
+    interactiveAuthEnabled?: boolean;
     authorization?: OAuthAuthorization;
 }
 export interface McpAuthOrchestration {

package/dist/chat/services/plugin-auth-orchestration.d.ts

@@ -12,7 +12,7 @@
  */
 import type { Destination, Source } from "@sentry/junior-plugin-api";
 import type { UserTokenStore } from "@/chat/credentials/user-token-store";
-import { AuthorizationPauseError, type AuthorizationFlowMode } from "@/chat/services/auth-pause";
+import { AuthorizationPauseError } from "@/chat/services/auth-pause";
 import type { ConversationPendingAuthState } from "@/chat/state/conversation";
 import { type OAuthAuthorization } from "@/chat/oauth-authorization";
 export declare class PluginAuthorizationPauseError extends AuthorizationPauseError {
@@ -34,7 +34,8 @@ export interface PluginAuthOrchestrationInput {
     userMessage?: string;
     pendingAuth?: ConversationPendingAuthState;
     recordPendingAuth?: (pendingAuth: ConversationPendingAuthState) => void | Promise<void>;
-    authorizationFlowMode?: AuthorizationFlowMode;
+    /** When false, required auth hard-fails instead of pausing for an OAuth link. */
+    interactiveAuthEnabled?: boolean;
     userTokenStore?: UserTokenStore;
     authorization?: OAuthAuthorization;
 }

package/dist/chat/state/turn-session.d.ts

@@ -26,12 +26,10 @@ export interface AgentTurnSessionRecord {
     conversationId: string;
     cumulativeDurationMs: number;
     cumulativeUsage?: AgentTurnUsage;
-    destination?: Destination;
     dispatchId?: string;
     dispatchOutcome?: AgentDispatchOutcome;
     /** Provider-owned identifier returned after visible delivery is accepted. */
     resultMessageId?: string;
-    source?: Source;
     errorMessage?: string;
     lastProgressAtMs: number;
     loadedSkillNames?: string[];
@@ -44,11 +42,9 @@ export interface AgentTurnSessionRecord {
      * All distinct actors annotated on this run's committed instruction-authority
      * messages, in first-seen order. Persisted as an attribution handle so a
      * summary-only handoff cannot erase them. It never grants authority or
-     * replaces the singular execution actor.
+     * replaces the singular execution actor, which is rebuilt at resume.
      */
     actors: Actor[];
-    /** The single actor this run executes as (credential binding, auth flows). */
-    actor?: Actor;
     resumeReason?: AgentTurnResumeReason;
     resumedFromSliceId?: number;
     sessionId: string;

package/dist/chat/task-execution/state.d.ts

@@ -13,6 +13,7 @@ export declare const CONVERSATION_WORK_LEASE_TTL_MS = 90000;
 export declare const CONVERSATION_WORK_CHECK_IN_INTERVAL_MS = 15000;
 export declare const CONVERSATION_WORK_STALE_ENQUEUE_MS = 60000;
 export declare const CONVERSATION_WORK_MAX_DELIVERY_ATTEMPTS = 5;
+export declare const CONVERSATION_WORK_MAX_RETRIES = 5;
 declare const inboundMessageSourceSchema: z.ZodEnum<{
     slack: "slack";
     plugin: "plugin";
@@ -46,14 +47,14 @@ export declare const inboundMessageSchema: z.ZodObject<{
         defer: "defer";
         interrupt: "interrupt";
     }>;
-    destination: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    destination: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
         platform: z.ZodLiteral<"slack">;
         teamId: z.ZodString;
         channelId: z.ZodString;
     }, z.core.$strict>, z.ZodObject<{
         platform: z.ZodLiteral<"local">;
         conversationId: z.ZodString;
-    }, z.core.$strict>], "platform">;
+    }, z.core.$strict>], "platform">>;
     inboundMessageId: z.ZodString;
     injectedAtMs: z.ZodOptional<z.ZodNumber>;
     input: z.ZodObject<{
@@ -84,6 +85,8 @@ export interface ConversationExecution {
     inboundMessageIds: string[];
     lastCheckpointAtMs?: number;
     lastEnqueuedAtMs?: number;
+    lastProgressAtMs?: number;
+    retryCount?: number;
     lease?: Lease;
     pendingCount: number;
     pendingMessages: InboundMessage[];
@@ -163,7 +166,7 @@ export declare function appendInboundMessage(args: {
 /** Mark a conversation runnable when there is no new mailbox message. */
 export declare function requestConversationWork(args: {
     conversationId: string;
-    destination: Destination;
+    destination?: Destination;
     nowMs?: number;
     state?: StateAdapter;
 }): Promise<RequestConversationWorkResult>;
@@ -251,7 +254,7 @@ export declare function ackMessages(args: {
 /** Mark the leased conversation as needing another queue-delivered slice. */
 export declare function requestConversationContinuation(args: {
     conversationId: string;
-    destination: Destination;
+    destination?: Destination;
     leaseToken: string;
     nowMs?: number;
     state?: StateAdapter;
@@ -270,25 +273,34 @@ export declare function releaseConversationWork(args: {
     nowMs?: number;
     state?: StateAdapter;
 }): Promise<boolean>;
+/** Count one failed execution attempt and stop the conversation when retries are exhausted. */
+export declare function recordConversationRetry(args: {
+    conversationId: string;
+    leaseToken: string;
+    nowMs?: number;
+    state?: StateAdapter;
+}): Promise<"lost_lease" | "recorded" | "stopped">;
 /** Finish a leased conversation and report whether runnable work remains. */
 export declare function completeConversationWork(args: {
     conversationId: string;
     leaseToken: string;
+    madeProgress?: boolean;
     nowMs?: number;
     state?: StateAdapter;
 }): Promise<"completed" | "lost_lease" | "pending">;
-/** Failure outcome: `lost_lease` (another owner took over), `recorded` (attempt counted), or `skipped` (durable progress was made). */
+/** Failure outcome: `lost_lease` (another owner took over), `recorded` (retry counted), or `skipped` (durable progress was made). */
 export interface AttemptFailure {
     pendingCount: number;
     deadLetteredMessages: InboundMessage[];
+    retryCount: number;
     status: "lost_lease" | "recorded" | "skipped";
 }
 /**
- * Record one failed delivery attempt for the pending messages a run attempted,
- * dead-lettering messages that reach the retry limit so a deterministic
- * failure cannot requeue forever.
+ * Record one failed execution attempt for pending messages, dead-lettering
+ * the conversation when its retry budget or the legacy message delivery limit
+ * is exhausted.
  *
- * Attempts are counted only when the run made no durable progress: if any
+ * Retries are counted only when the run made no durable progress: if any
  * attempted message left the mailbox, the remaining pending entries may be
  * deliberate deferrals and are left untouched. Consumed message ids stay in
  * `inboundMessageIds` so source retries remain duplicates.
@@ -307,12 +319,12 @@ export declare function deadLetterAttempt(args: {
     nowMs?: number;
     state?: StateAdapter;
 }): Promise<"failed" | "lost_lease" | "pending">;
-/** Clear an expired durable lease so a later worker can resume safely. */
+/** Recover an expired lease, consuming the retry budget under the mutation lock. */
 export declare function clearExpiredConversationLease(args: {
     conversationId: string;
     nowMs?: number;
     state?: StateAdapter;
-}): Promise<boolean>;
+}): Promise<"not_expired" | "requeued" | "stopped">;
 /** Delete one conversation mailbox and all of its index entries. */
 export declare function deleteConversationState(args: {
     conversationId: string;

package/dist/chat/task-execution/store.d.ts

@@ -2,7 +2,7 @@ import type { StateAdapter } from "chat";
 import type { ConversationStore } from "@/chat/conversations/store";
 import type { ConversationWorkQueue } from "./queue";
 import * as workState from "./state";
-export { CONVERSATION_ACTIVE_INDEX_KEY, CONVERSATION_BY_ACTIVITY_INDEX_KEY, CONVERSATION_WORK_CHECK_IN_INTERVAL_MS, CONVERSATION_WORK_LEASE_TTL_MS, CONVERSATION_WORK_MAX_DELIVERY_ATTEMPTS, CONVERSATION_WORK_STALE_ENQUEUE_MS, isFinalAttempt, isInvalidConversationRecordError, type AgentInput, type AttemptFailure, type AppendAndEnqueueInboundMessageResult, type AppendInboundMessageResult, type Conversation, type ConversationExecution, type ConversationWorkLease, type ConversationWorkState, type ExecutionStatus, type InboundMessage, type InboundMessageDelivery, type Lease, type RequestConversationWorkResult, type Source, type StartConversationWorkAcquired, type StartConversationWorkActive, type StartConversationWorkNoWork, type StartConversationWorkResult, } from "@/chat/task-execution/state";
+export { CONVERSATION_ACTIVE_INDEX_KEY, CONVERSATION_BY_ACTIVITY_INDEX_KEY, CONVERSATION_WORK_CHECK_IN_INTERVAL_MS, CONVERSATION_WORK_LEASE_TTL_MS, CONVERSATION_WORK_MAX_DELIVERY_ATTEMPTS, CONVERSATION_WORK_MAX_RETRIES, CONVERSATION_WORK_STALE_ENQUEUE_MS, isFinalAttempt, isInvalidConversationRecordError, type AgentInput, type AttemptFailure, type AppendAndEnqueueInboundMessageResult, type AppendInboundMessageResult, type Conversation, type ConversationExecution, type ConversationWorkLease, type ConversationWorkState, type ExecutionStatus, type InboundMessage, type InboundMessageDelivery, type Lease, type RequestConversationWorkResult, type Source, type StartConversationWorkAcquired, type StartConversationWorkActive, type StartConversationWorkNoWork, type StartConversationWorkResult, } from "@/chat/task-execution/state";
 import type { AppendAndEnqueueInboundMessageResult, Conversation, InboundMessage } from "@/chat/task-execution/state";
 export type EnsureConversationWakeResult = {
     queueMessageId?: string;
@@ -20,6 +20,14 @@ export declare function getConversationWorkState(args: {
     conversationId: string;
     state?: StateAdapter;
 }): Promise<workState.ConversationWorkState | undefined>;
+/** Count one failed conversation execution and persist its terminal retry state. */
+export declare function recordConversationRetry(args: {
+    conversationId: string;
+    conversationStore?: ConversationStore;
+    leaseToken: string;
+    nowMs?: number;
+    state?: StateAdapter;
+}): Promise<"stopped" | "lost_lease" | "recorded">;
 /** Count mailbox messages that have not yet reached the conversation event log. */
 export declare function countPendingConversationMessages(conversation: Conversation): number;
 /** Return whether a conversation has pending or resumable execution work. */
@@ -98,14 +106,6 @@ export declare function drainConversationMailbox(args: Parameters<typeof workSta
     conversationId: string;
     createdAtMs: number;
     delivery: "defer" | "interrupt";
-    destination: {
-        platform: "slack";
-        teamId: string;
-        channelId: string;
-    } | {
-        platform: "local";
-        conversationId: string;
-    };
     inboundMessageId: string;
     input: {
         text: string;
@@ -116,6 +116,14 @@ export declare function drainConversationMailbox(args: Parameters<typeof workSta
     receivedAtMs: number;
     source: "slack" | "plugin" | "local" | "api" | "internal" | "resource_event" | "scheduler";
     attemptCount?: number | undefined;
+    destination?: {
+        platform: "slack";
+        teamId: string;
+        channelId: string;
+    } | {
+        platform: "local";
+        conversationId: string;
+    } | undefined;
     injectedAtMs?: number | undefined;
 }[]>;
 /** Acknowledge leased mailbox entries after the handler accepts responsibility. */
@@ -156,6 +164,7 @@ export declare function releaseConversationWork(args: {
 export declare function completeConversationWork(args: {
     conversationId: string;
     leaseToken: string;
+    madeProgress?: boolean;
     conversationStore?: ConversationStore;
     nowMs?: number;
     state?: StateAdapter;
@@ -177,13 +186,13 @@ export declare function deadLetterAttempt(args: {
     nowMs?: number;
     state?: StateAdapter;
 }): Promise<"pending" | "failed" | "lost_lease">;
-/** Clear an expired durable lease so a later worker can resume safely. */
+/** Recover an expired lease and persist the resulting retry state. */
 export declare function clearExpiredConversationLease(args: {
     conversationId: string;
     conversationStore?: ConversationStore;
     nowMs?: number;
     state?: StateAdapter;
-}): Promise<boolean>;
+}): Promise<"stopped" | "not_expired" | "requeued">;
 /** Remove one conversation from the active index after it is missing or idle. */
 export declare function removeActiveConversation(args: {
     conversationId: string;

package/dist/chat/task-execution/worker.d.ts

@@ -8,13 +8,13 @@ export interface ConversationWorkerContext {
     attempt: InboxAttempt;
     checkIn(): Promise<boolean>;
     conversationId: string;
-    destination: Destination;
+    destination?: Destination;
     shouldYield(): boolean;
 }
 export interface InboxAttempt {
     ack(): Promise<void>;
     conversationId: string;
-    destination: Destination;
+    destination?: Destination;
     drain(handle: (messages: InboundMessage[]) => Promise<readonly string[] | void>): Promise<InboundMessage[]>;
     isFinalAttempt: boolean;
     messages: InboundMessage[];

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

@@ -1,4 +1,6 @@
+import { type TaskExecutionStatus } from "@/db/schema/task-executions";
 export declare const TASK_EXECUTION_TYPES: readonly ["scheduled", "event"];
+export declare const TASK_EXECUTION_STATUSES: readonly ["blocked", "completed", "failed"];
 export type TaskExecutionType = (typeof TASK_EXECUTION_TYPES)[number];
 export type TaskExecutionDay = {
     date: string;
@@ -11,18 +13,47 @@ export type TaskExecutionSummary = {
     runsLast7Days: number;
     totalRuns: number;
 };
-/** Record one successful task execution and its durable conversation. */
+export type TaskExecutionRecord = {
+    conversationId?: string;
+    executedAt: string;
+    executionId: string;
+    status: TaskExecutionStatus;
+    title?: string;
+};
+export type TaskExecutionStatusDay = {
+    blocked: number;
+    completed: number;
+    date: string;
+    failed: number;
+};
+/** Record one terminal task execution and its durable conversation when present. */
 export declare function recordTaskExecution(type: TaskExecutionType, taskId: string, options: {
-    conversationId: string;
+    conversationId?: string;
     executionId: string;
     namespace?: string;
     nowMs?: number;
+    status?: TaskExecutionStatus;
 }): Promise<void>;
 /** Load usage analytics for all tasks of one type and namespace. */
 export declare function readTaskExecutionSummaries(type: TaskExecutionType, namespace: string, options?: {
     nowMs?: number;
 }): Promise<Map<string, TaskExecutionSummary>>;
-/** Load a fixed trailing window of successful executions stacked by task type. */
+/** Load a fixed trailing window of completed executions stacked by task type. */
 export declare function readTaskExecutionDays(dayCount?: number, options?: {
     nowMs?: number;
 }): Promise<TaskExecutionDay[]>;
+/** Load newest-first executions for one task, with conversation titles when present. */
+export declare function readTaskExecutions(args: {
+    kind: TaskExecutionType;
+    limit: number;
+    namespace?: string;
+    taskId: string;
+}): Promise<TaskExecutionRecord[]>;
+/** Load a fixed trailing window of terminal executions for one task by status. */
+export declare function readTaskExecutionStatusDays(args: {
+    dayCount?: number;
+    kind: TaskExecutionType;
+    namespace?: string;
+    nowMs?: number;
+    taskId: string;
+}): Promise<TaskExecutionStatusDay[]>;

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

@@ -1,9 +1,11 @@
 import type { User } from "@sentry/junior-plugin-api";
-import type { TaskList } from "@/api/schema/task";
+import type { TaskExecutionList, TaskList } 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>;
 export declare class ViewerTaskNotFoundError extends Error {
     constructor();
 }
+/** Read one viewer-visible task and its newest terminal executions. */
+export declare function readViewerTaskExecutions(user: User, kind: "scheduled" | "event", id: string): Promise<TaskExecutionList>;
 /** Delete one viewer-owned scheduled or event task. */
 export declare function deleteViewerTask(user: User, kind: "scheduled" | "event", id: string): Promise<void>;

package/dist/chat/tools/runtime/spawn-agent.d.ts

@@ -0,0 +1,31 @@
+import type { ToolRuntimeContext } from "@/chat/tools/types";
+export declare const SPAWN_AGENT_TOOL_NAME = "spawnAgent";
+/** Create the asynchronous child-agent tool for one parent run. */
+export declare function createSpawnAgentTool(spawnAgent: NonNullable<ToolRuntimeContext["spawnAgent"]>): Omit<import("../definition").AnyToolDefinition, "inputSchema" | "outputSchema" | "prepareArguments" | "execute"> & {
+    inputSchema: import("../definition").JsonSchemaObject;
+    outputSchema: import("../definition").JsonSchemaObject;
+    prepareArguments(args: unknown): {
+        task: string;
+        name?: string | null | undefined;
+        reasoning_level?: "low" | "medium" | "high" | "xhigh" | "none" | null | undefined;
+    };
+    execute?: ((input: unknown, options: import("../definition").ToolExecuteOptions) => {
+        [x: string]: unknown;
+        invocation_id: string;
+        target?: string | undefined;
+        truncated?: boolean | undefined;
+        continuation?: {
+            arguments: Record<string, unknown>;
+            reason?: string | undefined;
+        } | undefined;
+    } | Promise<{
+        [x: string]: unknown;
+        invocation_id: string;
+        target?: string | undefined;
+        truncated?: boolean | undefined;
+        continuation?: {
+            arguments: Record<string, unknown>;
+            reason?: string | undefined;
+        } | undefined;
+    }>) | undefined;
+};

package/dist/chat/tools/types.d.ts

@@ -11,6 +11,7 @@ import type { LocalActor, Actor, SlackActor } from "@/chat/actor";
 import type { SlackActionToken } from "@/chat/slack/action-token";
 import type { ModelProfile } from "@/chat/model-profile";
 import type { GeneratedArtifactFileRef } from "@/chat/tools/sandbox/file-uploads";
+import type { SpawnAgent } from "@/chat/agent/request";
 interface HandoffControl {
     /** Non-empty catalog of configured targets. */
     profiles: readonly [ModelProfile, ...ModelProfile[]];
@@ -55,6 +56,7 @@ export interface ToolHooks {
 }
 interface BaseToolRuntimeContext {
     handoff?: HandoffControl;
+    spawnAgent?: SpawnAgent;
     /**
      * Opaque Junior conversation/session identity for this turn.
      * Interactive Slack turns use `slack:{channelId}:{threadTs}`.

package/dist/{chunk-T6Z5S6PQ.js → chunk-2ECYPYKP.js}

@@ -9,7 +9,7 @@ import {
 } from "./chunk-6GWA276C.js";
 import {
   getDeploymentTelemetryAttributes
-} from "./chunk-5PNJMOY5.js";
+} from "./chunk-C2N6MNO4.js";
 
 // src/chat/logging.ts
 import path from "path";