@sentry/junior 0.148.0 → 0.150.0

package/dist/chat/agent/prompt.d.ts

@@ -7,7 +7,7 @@ import type { ToolRuntimeContext } from "@/chat/tools/types";
 import type { AnyToolDefinition } from "@/chat/tools/definition";
 import { type Actor } from "@/chat/actor";
 import type { PluginTurnContext } from "@/chat/plugins/prompt";
-import type { AgentRunInput, AgentRunInstructionActor, AgentRunRouting, AgentRunSteeringMessage } from "@/chat/agent/request";
+import type { AgentInstruction, AgentInstructionActor, AgentRun, AgentSteeringMessage } from "@/chat/agent/types";
 export type UserContentPart = {
     type: "text";
     text: string;
@@ -38,7 +38,7 @@ export interface PromptAssembly {
     userContentParts: UserContentPart[];
 }
 /** Render the current actor's instruction without host-owned thread context. */
-export declare function buildUserTurnText(userInput: string, actor?: AgentRunInstructionActor): string;
+export declare function buildUserTurnText(userInput: string, actor?: AgentInstructionActor): string;
 /** Render an explicitly selected skill as instructions for the current turn. */
 export declare function renderExplicitSkillInstructions(skill: Skill): string;
 /** Encode a non-image attachment as base64 XML for the prompt. */
@@ -50,13 +50,16 @@ export declare function encodeNonImageAttachmentForPrompt(attachment: {
 /** Redact image data from prompt content parts for observability. */
 export declare function toObservablePromptPart(part: UserContentPart): Record<string, unknown>;
 /** Build the prompt-facing user input, keeping router text aligned with Pi content. */
-export declare function buildPromptInput(input: AgentRunInput): PromptInput;
+export declare function buildPromptInput(args: {
+    instruction: AgentInstruction;
+    history?: readonly import("@/chat/pi/messages").PiMessage[];
+}): PromptInput;
 /**
  * Convert a mid-run user message into the Pi user message shape used for
  * steering injection and parked-conversation event-log appends, so both
  * paths store identical durable history.
  */
-export declare function buildSteeringPiMessage(message: AgentRunSteeringMessage): PiMessage;
+export declare function buildSteeringPiMessage(message: AgentSteeringMessage): PiMessage;
 /** Assemble prompt history, instructions, and telemetry input for one slice. */
 export declare function assemblePrompt(args: {
     activeMcpCatalogs: ActiveMcpCatalogSummary[];
@@ -70,7 +73,7 @@ export declare function assemblePrompt(args: {
     explicitSkill: Skill | null;
     priorPiMessages?: PiMessage[];
     resumedFromSessionRecord: boolean;
-    routing: AgentRunRouting;
+    run: Pick<AgentRun, "source" | "destination" | "dispatch" | "slackConversation">;
     spanContext: LogContext;
     turnId: string;
     toolGuidance: Array<{

package/dist/chat/agent/resume.d.ts

@@ -12,7 +12,7 @@ import type { Actor } from "@/chat/actor";
 import { type AgentTurnSurface, type TurnCheckpoint } from "@/chat/task-execution/checkpoint";
 import { type AuthorizationPauseError } from "@/chat/services/auth-pause";
 import { type AgentTurnUsage } from "@/chat/usage";
-import { type AgentRunDurability } from "@/chat/agent/request";
+import { type AgentDurability } from "@/chat/agent/types";
 import type { PluginTurnContext } from "@/chat/plugins/prompt";
 import type { ConversationPrivacy } from "@/chat/conversation-privacy";
 interface ResumeStateArgs {
@@ -20,7 +20,7 @@ interface ResumeStateArgs {
     destination: Destination;
     destinationVisibility?: ConversationPrivacy;
     dispatchId?: string;
-    durability: AgentRunDurability;
+    durability: AgentDurability;
     recordActiveMcpProviders: () => Promise<void>;
     publishExternally: boolean;
     actor?: Actor;

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

@@ -25,7 +25,7 @@ import type { OAuthAuthorization } from "@/chat/oauth-authorization";
 import type { Actor } from "@/chat/actor";
 import type { AuthorizationPauseError } from "@/chat/services/auth-pause";
 import type { AgentTurnSurface } from "@/chat/task-execution/checkpoint";
-import { type AgentRunDurability, type AgentRunObservers, type AgentRunPolicy, type AgentRunRouting, type AgentRunState } from "@/chat/agent/request";
+import { type AgentDurability, type AgentEvent, type AgentRun, type AgentRunState } from "@/chat/agent/types";
 import type { ResumeState } from "@/chat/agent/resume";
 interface ToolWiringArgs {
     abortAgent: () => void;
@@ -43,22 +43,19 @@ interface ToolWiringArgs {
     configurationValues: Record<string, unknown>;
     connectedMcpProviders: Set<string>;
     conversationPrivacy?: ConversationPrivacy;
-    durability: AgentRunDurability;
+    durability: AgentDurability;
     authorization?: OAuthAuthorization;
     generatedFiles: FileUpload[];
     invokedSkill: SkillMetadata | null;
-    observers: AgentRunObservers;
+    onEvent?: (event: AgentEvent) => void | Promise<void>;
     onFatalToolError(error: Error): void;
     onSandboxRefChanged: (sandboxRef: SandboxRef) => void;
-    policy: AgentRunPolicy;
     preAgentPromptMessages: () => PiMessage[];
     priorPiMessages: PiMessage[] | undefined;
     recordConnectedMcpProvider: (provider: string) => Promise<void>;
     requestHandoff?: ToolRuntimeContext["handoff"];
     resume: ResumeState;
-    routing: AgentRunRouting;
-    conversationId: string;
-    turnId: string;
+    run: AgentRun;
     skillSandbox: SkillSandbox;
     spanContext: LogContext;
     state: AgentRunState;

package/dist/chat/agent/{request.d.ts → types.d.ts}

@@ -1,11 +1,9 @@
 /**
- * Agent run request contract.
+ * Public agent-run launch contract.
  *
- * Groups the per-slice run request by the runtime role each field serves and
- * owns interpretation of the routing group: actor derivation, surface
- * inference, destination consistency checks, and session identifiers. Run
- * phases consume these groups directly; callers build them at runtime
- * boundaries.
+ * Providers build one flat `AgentRun` and call `AgentRunner.run`. Delivery and
+ * durability are capabilities that affect the run. `onEvent` is best-effort UI
+ * only. Stable composition binds stream, spawn, and tracing outside this type.
  */
 import type { Destination, ReplyAttribution, Source, SystemActor } from "@sentry/junior-plugin-api";
 import type { LocationConfigurationService } from "@/chat/configuration/types";
@@ -17,7 +15,6 @@ import type { SandboxRef } from "@/chat/sandbox/ref";
 import type { SandboxEgressTracePropagationConfig } from "@/chat/sandbox/egress/tracing";
 import type { SandboxEgressSignalTransport } from "@/chat/sandbox/egress/signals";
 import type { OAuthAuthorization } from "@/chat/oauth-authorization";
-import type { AssistantStatusSpec } from "@/chat/slack/assistant-thread/status";
 import type { SlackConversationContext } from "@/chat/slack/conversation-context";
 import type { ConversationPendingAuthState } from "@/chat/state/conversation";
 import type { ConversationMessageProvenance } from "@/chat/conversations/provenance";
@@ -27,26 +24,33 @@ import type { SlackActionToken } from "@/chat/slack/action-token";
 import type { TurnReasoningLevel } from "@/chat/reasoning-level";
 import type { ImageGenerateToolDeps, ViewImageToolDeps, WebFetchToolDeps, WebSearchToolDeps } from "@/chat/tools/types";
 import type { AssistantMessage } from "@earendil-works/pi-ai";
-export interface AgentRunAttachment {
+/** One attachment the model may see for the current instruction. */
+export type AgentAttachment = {
     data?: Buffer;
     mediaType: string;
     filename?: string;
     promptText?: string;
-}
-export interface AgentRunInstructionActor {
+};
+/** Instruction author metadata used for prompt labels and provenance. */
+export type AgentInstructionActor = {
     authorId?: string;
     authorName?: string;
+    /**
+     * Slack message ts for the instruction when known.
+     * TODO: generalize to a provider-neutral message id once prompt attrs are neutral.
+     */
     slackTs?: string;
-}
-export interface AgentRunSteeringMessage {
-    actor?: AgentRunInstructionActor;
+};
+/** One mid-turn steered user message drained from the durable mailbox. */
+export type AgentSteeringMessage = {
+    actor?: AgentInstructionActor;
     /** Provenance of this queued/steered message, carrying its original author. */
     provenance: ConversationMessageProvenance;
     omittedImageAttachmentCount?: number;
     text: string;
     timestampMs?: number;
-    userAttachments?: AgentRunAttachment[];
-}
+    attachments?: AgentAttachment[];
+};
 /** Model-safe input for one asynchronously delegated child-agent task. */
 export type SpawnAgentInput = {
     name?: string;
@@ -62,155 +66,160 @@ export type SpawnAgent = (input: SpawnAgentInput, options: {
     signal?: AbortSignal;
     toolCallId: string;
 }) => Promise<SpawnAgentResult>;
-/** Carries the user-visible content and prior transcript for one agent-run slice. */
-export interface AgentRunInput {
-    actor?: AgentRunInstructionActor;
-    includeConversationContextWithPiMessages?: boolean;
-    messageText: string;
-    userAttachments?: AgentRunAttachment[];
+/** Current user instruction for one agent-run slice. */
+export type AgentInstruction = {
+    text: string;
+    attachments?: readonly AgentAttachment[];
     inboundAttachmentCount?: number;
     omittedImageAttachmentCount?: number;
-    /** Durable Pi transcript for this conversation, excluding ephemeral turn context. */
-    piMessages?: PiMessage[];
-    conversationContext?: string;
-}
-/**
- * Identity and addressing for one run.
- *
- * Set `actor` first (who runs). Derive `credentialContext` with
- * `credentialContextForActor(actor, subject?)` unless a caller already bound
- * credentials (dispatch with delegated subject). They name the same principal
- * except when a system actor carries `credentialContext.subject` for delegated
- * user tokens.
- */
-export interface AgentRunRouting {
-    /** Who this run executes as. Prefer always setting this. */
-    actor?: Actor;
-    /** Credential authority projected from actor (plus optional subject). */
-    credentialContext?: CredentialContext;
-    source: Source;
-    slackConversation?: SlackConversationContext;
+    /** Host-owned turn context shown to the model near the instruction. */
+    context?: string;
+    actor?: AgentInstructionActor;
     /**
-     * TODO: Move ephemeral Slack credentials into provider-owned turn context so
-     * the Slack tool registry can consume them without extending core routing.
+     * When history is present, still include `context` in the prompt. Default is
+     * to omit conversation context once durable history already carries it.
      */
-    slackActionToken?: SlackActionToken;
-    destination: Destination;
-    /** When true, also publish assistant output to the conversation destination. */
-    publishExternally?: boolean;
-    /** Confirmed visibility of the destination where this run is delivered. */
-    destinationVisibility?: ConversationPrivacy;
-    surface?: AgentTurnSurface;
-    dispatch?: {
-        actor?: SystemActor;
-        id: string;
-        metadata?: Record<string, string>;
-        plugin?: string;
-        replyAttribution?: ReplyAttribution;
-    };
-    toolChannelId?: string;
-}
+    includeConversationContextWithHistory?: boolean;
+};
+/** Dispatch identity carried on plugin-authored runs. */
+export type AgentDispatch = {
+    actor?: SystemActor;
+    id: string;
+    metadata?: Record<string, string>;
+    plugin?: string;
+    replyAttribution?: ReplyAttribution;
+};
 /** Optional agent capabilities that a run slice can turn off. */
 export declare const AGENT_RUN_FEATURES: readonly ["handoff", "interactive-auth", "subagents"];
-/** One optional agent capability controlled by run policy. */
-export type AgentRunFeature = (typeof AGENT_RUN_FEATURES)[number];
-/** Return whether one optional agent capability is disabled for this run. */
-export declare function isAgentRunFeatureDisabled(policy: Pick<AgentRunPolicy, "disabledFeatures"> | undefined, feature: AgentRunFeature): boolean;
-/** Carries execution limits and dependency overrides for one run slice. */
-export interface AgentRunPolicy {
-    /**
-     * Optional agent capabilities disabled for this run slice.
-     * `interactive-auth` blocks pausing to send an OAuth link; missing credentials
-     * hard-fail instead. Default is enabled when omitted.
-     * TODO(#881, #883): child invocations currently disable interactive-auth, but
-     * may later need a path to force the auth flow when a delegated tool requires
-     * credentials the parent can already request.
-     */
-    disabledFeatures?: readonly AgentRunFeature[];
-    /** Absolute wall-clock deadline for this host request, in milliseconds. */
-    turnDeadlineAtMs?: number;
-    /** Cancels provider work when the owning host request is abandoned. */
-    signal?: AbortSignal;
-    /** Explicit per-agent reasoning level. When set, adaptive routing is disabled. */
-    reasoningLevel?: TurnReasoningLevel;
-    configuration?: Record<string, unknown>;
-    locationConfiguration?: LocationConfigurationService;
-    skillDirs?: string[];
-    /** Per-slice override for app-owned sandbox egress trace propagation. */
-    sandboxTracePropagation?: SandboxEgressTracePropagationConfig;
-    /** Per-slice sandbox egress signal storage override. */
-    sandboxEgressSignals?: SandboxEgressSignalTransport;
-    toolOverrides?: {
-        imageGenerate?: ImageGenerateToolDeps;
-        viewImage?: ViewImageToolDeps;
-        webFetch?: WebFetchToolDeps;
-        webSearch?: WebSearchToolDeps;
-    };
-}
-/** Carries durable state snapshots already loaded by the caller. */
-export interface AgentRunState {
+/** One optional agent capability controlled per run. */
+export type AgentFeature = (typeof AGENT_RUN_FEATURES)[number];
+/** Already-loaded resume state for this conversation. */
+export type AgentRunState = {
     pendingAuth?: ConversationPendingAuthState;
     /** Persisted sandbox reuse state from prior slices of this conversation. */
     sandboxRef?: SandboxRef;
-}
-/**
- * Carries notification-only callbacks for streaming UI and status surfaces;
- * their failures never affect the run.
- */
-export interface AgentRunObservers {
-    onToolInvocation?: (invocation: {
-        params: Record<string, unknown>;
-        toolCallId: string;
-        toolName: string;
-    }) => void | Promise<void>;
-    onToolResult?: (result: ToolExecutionReport) => void | Promise<void>;
-    onStatus?: (status: AssistantStatusSpec) => void | Promise<void>;
-}
+};
 /**
  * Delivers completed tool-free assistant messages in model order.
  *
  * The runner must commit the preceding agent boundary before invoking this
  * port; the accepted reply transaction appends only this message.
  */
-export type AgentRunDelivery = (message: AssistantMessage) => void | Promise<void>;
+export type AgentDelivery = (message: AssistantMessage) => void | Promise<void>;
 /** Resume the agent turn after a transient or ambiguous delivery failure. */
 export declare class RetryableDeliveryError extends Error {
     constructor(cause: unknown);
 }
-/** Carries durable-worker ports that commit or update resumable run state. */
-export interface AgentRunDurability {
+/** Durable-worker ports that commit or update resumable run state. */
+export type AgentDurability = {
     /** Schedule delegated work with authority bound by the active parent run. */
     spawnAgent?: SpawnAgent;
     onInputCommitted?: () => void | Promise<void>;
     /** Return true when the durable worker should pause at the next Pi boundary. */
     shouldYield?: () => boolean;
-    drainSteeringMessages?: (accept: (messages: AgentRunSteeringMessage[]) => Promise<void>) => Promise<AgentRunSteeringMessage[]>;
+    drainSteeringMessages?: (accept: (messages: AgentSteeringMessage[]) => Promise<void>) => Promise<AgentSteeringMessage[]>;
     recordPendingAuth?: (pendingAuth: ConversationPendingAuthState | undefined) => void | Promise<void>;
     onSandboxRefChanged?: (sandboxRef: SandboxRef) => void | Promise<void>;
-}
-/** Groups the per-slice run request by the runtime role each field serves. */
-export interface AgentRunRequest {
+};
+/** Best-effort progress events. Failures here never affect the run. */
+export type AgentEvent = {
+    type: "status";
+    text: string;
+} | {
+    type: "tool_started";
+    toolCallId: string;
+    toolName: string;
+    params: Record<string, unknown>;
+} | {
+    type: "tool_finished";
+    report: ToolExecutionReport;
+};
+/** Resolved environment and optional per-run tool test overrides. */
+export type AgentEnvironment = {
+    configuration?: Record<string, unknown>;
+    locationConfiguration?: LocationConfigurationService;
+    skillDirs?: string[];
+    /** Per-slice override for app-owned sandbox egress trace propagation. */
+    sandboxTracePropagation?: SandboxEgressTracePropagationConfig;
+    /** Per-slice sandbox egress signal storage override. */
+    sandboxEgressSignals?: SandboxEgressSignalTransport;
+    toolOverrides?: {
+        imageGenerate?: ImageGenerateToolDeps;
+        viewImage?: ViewImageToolDeps;
+        webFetch?: WebFetchToolDeps;
+        webSearch?: WebSearchToolDeps;
+    };
+};
+/**
+ * One provider-launched agent-run slice.
+ *
+ * Build identity, instruction, history, delivery, and durability here. Bind
+ * stable model/stream composition when creating the runner, not on each run.
+ */
+export type AgentRun = {
     /** Durable conversation advanced by this run. */
     conversationId: string;
     /** Stable turn advanced across this run and any continuation runs. */
     turnId: string;
     /** Optional bounded-run identifier used only for observability. */
     runId?: string;
-    input: AgentRunInput;
-    routing: AgentRunRouting;
+    instruction: AgentInstruction;
+    /** Durable Pi transcript for this conversation, excluding ephemeral turn context. */
+    history?: readonly PiMessage[];
+    /**
+     * Who this run executes as. Prefer always setting this. Derive
+     * `credentialContext` with `credentialContextForActor(actor, subject?)`
+     * unless a caller already bound credentials.
+     */
+    actor?: Actor;
+    /** Credential authority projected from actor (plus optional subject). */
+    credentialContext?: CredentialContext;
+    source: Source;
+    destination: Destination;
+    /** When true, also publish assistant output to the conversation destination. */
+    publishExternally?: boolean;
+    /** Confirmed visibility of the destination where this run is delivered. */
+    destinationVisibility?: ConversationPrivacy;
+    surface?: AgentTurnSurface;
+    dispatch?: AgentDispatch;
+    /**
+     * TODO: Move ephemeral Slack credentials and conversation labels into
+     * provider-owned tool/prompt context so the shared run edge stays neutral.
+     */
+    slackConversation?: SlackConversationContext;
+    slackActionToken?: SlackActionToken;
+    toolChannelId?: string;
     /** Surface-owned OAuth state and private delivery capabilities. */
     authorization?: OAuthAuthorization;
-    policy?: AgentRunPolicy;
+    /**
+     * Optional agent capabilities disabled for this run slice.
+     * `interactive-auth` blocks pausing to send an OAuth link; missing credentials
+     * hard-fail instead. Default is enabled when omitted.
+     * TODO(#881, #883): child invocations currently disable interactive-auth, but
+     * may later need a path to force the auth flow when a delegated tool requires
+     * credentials the parent can already request.
+     */
+    disabledFeatures?: readonly AgentFeature[];
+    /** Absolute wall-clock deadline for this host request, in milliseconds. */
+    deadlineAtMs?: number;
+    /** Cancels provider work when the owning host request is abandoned. */
+    signal?: AbortSignal;
+    /** Explicit per-agent reasoning level. When set, adaptive routing is disabled. */
+    reasoning?: TurnReasoningLevel;
+    environment?: AgentEnvironment;
     state?: AgentRunState;
-    observers?: AgentRunObservers;
-    delivery?: AgentRunDelivery;
-    durability?: AgentRunDurability;
-}
-/** Resolve the explicit actor or the system credential actor for this run. */
-export declare function actorFromRouting(routing: AgentRunRouting): Actor | undefined;
+    /** Best-effort progress only. */
+    onEvent?: (event: AgentEvent) => void | Promise<void>;
+    delivery?: AgentDelivery;
+    durability?: AgentDurability;
+};
+/** Return whether one optional agent capability is disabled for this run. */
+export declare function isAgentRunFeatureDisabled(disabledFeatures: readonly AgentFeature[] | undefined, feature: AgentFeature): boolean;
+/** Resolve the explicit actor, dispatch actor, or credential actor for this run. */
+export declare function actorFromRun(run: Pick<AgentRun, "actor" | "dispatch" | "credentialContext">): Actor | undefined;
 /** Reject contradictory provider coordinates before the run touches state. */
-export declare function assertRunRoutingConsistency(request: Pick<AgentRunRequest, "conversationId" | "routing">): void;
+export declare function assertRunConsistency(run: Pick<AgentRun, "conversationId" | "source" | "destination" | "surface" | "publishExternally" | "actor" | "dispatch">): void;
 /** Route tool side effects to the tool channel when one overrides the destination. */
-export declare function toolInvocationDestination(routing: AgentRunRouting): Destination;
+export declare function toolInvocationDestination(run: Pick<AgentRun, "destination" | "toolChannelId">): Destination;
 /** Infer the run surface when the caller did not state one. */
-export declare function surfaceFromRouting(routing: AgentRunRouting): AgentTurnSurface;
+export declare function surfaceFromRun(run: Pick<AgentRun, "surface" | "source">): AgentTurnSurface;

package/dist/chat/agent-dispatch/types.d.ts

@@ -1,6 +1,6 @@
 import type { DispatchOptions, DestinationVisibility, ReplyAttribution, Source, SlackDestination } from "@sentry/junior-plugin-api";
 import type { CredentialContext, CredentialSubject, CredentialSystemActor } from "@/chat/credentials/context";
-import type { AgentRunRouting } from "@/chat/agent/request";
+import type { AgentDispatch } from "@/chat/agent/types";
 import type { AgentTurnSurface } from "@/chat/task-execution/checkpoint";
 import type { LocationConfigurationService } from "@/chat/configuration/types";
 export type DispatchStatus = "pending" | "running" | "awaiting_resume" | "completed" | "failed" | "blocked";
@@ -51,7 +51,7 @@ export interface DispatchTurnContext {
     locationConfiguration: LocationConfigurationService;
     credentialContext: CredentialContext;
     destinationVisibility: DestinationVisibility;
-    dispatch: NonNullable<AgentRunRouting["dispatch"]>;
+    dispatch: AgentDispatch;
     skipProviderDefaultConfig: true;
     source: Source;
     surface: Extract<AgentTurnSurface, "api">;

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

@@ -1,6 +1,6 @@
 import type { StateAdapter } from "chat";
 import type { ConversationStore } from "@/chat/conversations/store";
-import type { AgentRunRequest, SpawnAgent } from "@/chat/agent/request";
+import type { AgentRun, SpawnAgent } from "@/chat/agent/types";
 import type { ConversationWorkQueue } from "@/chat/task-execution/queue";
 type SpawnOptions = {
     conversationStore?: ConversationStore;
@@ -8,5 +8,5 @@ type SpawnOptions = {
     state?: StateAdapter;
 };
 /** Bind one run's runtime-owned authority to the model-safe spawn capability. */
-export declare function bindSpawnAgent(request: AgentRunRequest, options: SpawnOptions): SpawnAgent | undefined;
+export declare function bindSpawnAgent(run: AgentRun, options: SpawnOptions): SpawnAgent | undefined;
 export {};

package/dist/chat/api-turns/work.d.ts

@@ -1,6 +1,7 @@
 import { z } from "zod";
 import type { StateAdapter } from "chat";
 import { type Destination } from "@sentry/junior-plugin-api";
+import type { ConversationPrivacy } from "@/chat/conversation-privacy";
 import type { WebActor } from "@/chat/actor";
 import type { ConversationStore } from "@/chat/conversations/store";
 import { type ConversationTurnLifecycle } from "@/chat/conversations/turn-lifecycle";
@@ -28,12 +29,16 @@ export interface CreateApiConversationInput {
     message: string;
     /** Client-supplied idempotency key for the first message. */
     idempotencyKey: string;
+    /** New roots default public. Continues never rewrite visibility. */
+    visibility?: ConversationPrivacy;
 }
 export interface AppendApiConversationMessageInput {
     actor: WebActor;
     conversationId: string;
     message: string;
     idempotencyKey: string;
+    /** Applied only when this call creates the conversation root. */
+    rootVisibility?: ConversationPrivacy;
 }
 export interface ApiConversationMessageAccepted {
     conversationId: string;
@@ -68,7 +73,7 @@ export declare function buildApiTurnInboundMessage(args: {
     messageId: string;
     nowMs?: number;
 }): InboundMessage;
-/** Create a public root conversation and enqueue its first message. */
+/** Create a dashboard root conversation and enqueue its first message. */
 export declare function createAndEnqueueApiConversation(input: CreateApiConversationInput, options: EnqueueOptions): Promise<ApiConversationMessageAccepted>;
 /** Append one API message to an existing conversation and wake the worker. */
 export declare function appendAndEnqueueApiConversationMessage(input: AppendApiConversationMessageInput, options: EnqueueOptions): Promise<ApiConversationMessageAccepted>;

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

@@ -14,7 +14,7 @@ export interface JuniorRuntimeServices {
 export interface JuniorRuntimeServiceOverrides {
     conversationMemory?: Partial<ConversationMemoryDeps>;
     contextCompactor?: Partial<ContextCompactorDeps>;
-    replyExecutor?: Partial<Omit<ReplyExecutorServices, "generateThreadTitle">>;
+    replyExecutor?: Partial<ReplyExecutorServices>;
     subscribedReplyPolicy?: Partial<SubscribedReplyPolicyDeps>;
     sandbox?: {
         tracePropagation?: SandboxEgressTracePropagationConfig;

package/dist/chat/plugins/viewer.d.ts

@@ -4,6 +4,10 @@ import type { JuniorDatabase } from "@/db/db";
 export declare function resolveViewerUserFromSql(db: JuniorDatabase, email: string): Promise<User | undefined>;
 /** Resolve or create the canonical user for one authenticated viewer. */
 export declare function resolveViewerUser(email: string): Promise<User | undefined>;
+/** Update one canonical user's display name in SQL. */
+export declare function updateViewerDisplayNameFromSql(db: JuniorDatabase, userId: string, displayName: string): Promise<User | undefined>;
+/** Update one canonical user's display name. */
+export declare function updateViewerDisplayName(userId: string, displayName: string): Promise<User | undefined>;
 /** Resolve the stored identity and linked user for one runtime actor. */
 export declare function readActorIdentityFromSql(db: JuniorDatabase, actor: Actor): Promise<{
     identity: Identity;

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

@@ -1,12 +1,14 @@
-import { type AgentRunRequest, type SpawnAgent } from "@/chat/agent/request";
+import type { StreamFn } from "@earendil-works/pi-agent-core";
+import { type AgentRun, type SpawnAgent } from "@/chat/agent/types";
 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. */
 export interface AgentRunner {
-    run(request: AgentRunRequest): Promise<AgentRunOutcome>;
+    run(run: AgentRun): Promise<AgentRunOutcome>;
 }
-/** 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;
+/** Compose the agent executor with stable host dependencies. */
+export declare function createAgentRunner(execute: (run: AgentRun, streamFn?: StreamFn) => Promise<AgentRunOutcome>, options?: {
+    bindSpawnAgent?: (run: AgentRun) => SpawnAgent | undefined;
+    streamFn?: StreamFn;
     tracePropagation?: SandboxEgressTracePropagationConfig;
 }): AgentRunner;

package/dist/chat/runtime/reply-executor.d.ts

@@ -12,7 +12,6 @@ import { type Destination } from "@sentry/junior-plugin-api";
 import type { AgentRunner } from "@/chat/runtime/agent-runner";
 import type { PreparedTurnState } from "@/chat/runtime/turn-preparation";
 import { type PrepareTurnStateInput, type QueuedTurnMessage, type TurnToolInvocation } from "@/chat/runtime/turn-input";
-import { type ConversationMemoryService } from "@/chat/services/conversation-memory";
 import type { ContextCompactor } from "@/chat/services/context-compaction";
 import { lookupSlackUser } from "@/chat/slack/user";
 import type { PausedTurnRequest } from "@/chat/task-execution/turn-wake";
@@ -21,7 +20,6 @@ import type { DispatchTurnContext, DispatchTurnResult } from "@/chat/agent-dispa
 export interface ReplyExecutorServices {
     agentRunner: AgentRunner;
     contextCompactor: ContextCompactor;
-    generateThreadTitle: ConversationMemoryService["generateThreadTitle"];
     getPausedTurnRequest: (args: {
         conversationId: string;
         turnId: string;

package/dist/chat/runtime/slack-resume.d.ts

@@ -1,4 +1,4 @@
-import { type AgentRunRequest } from "@/chat/agent/request";
+import { type AgentRun } from "@/chat/agent/types";
 import type { AgentRunResult } from "@/chat/services/turn-result";
 import type { AgentRunner } from "@/chat/runtime/agent-runner";
 import { type ConversationTurnLifecycle } from "@/chat/conversations/turn-lifecycle";
@@ -44,8 +44,8 @@ interface ResumeSlackTurnArgs {
     beforeStart?: () => Promise<ResumePreparedTurn | false | void>;
     replyTimeoutMs?: number;
 }
-type ResumeReplyContext = Omit<AgentRunRequest, "conversationId" | "turnId" | "runId" | "input" | "delivery"> & {
-    input?: Omit<AgentRunRequest["input"], "messageText">;
+type ResumeReplyContext = Omit<AgentRun, "conversationId" | "turnId" | "runId" | "instruction" | "delivery"> & {
+    instruction?: Omit<AgentRun["instruction"], "text">;
 };
 interface ResumePreparedTurn {
     messageText: string;

package/dist/chat/services/conversation-memory.d.ts

@@ -11,7 +11,6 @@ export interface ConversationMemoryService {
         actorId?: string;
         runId?: string;
     }) => Promise<void>;
-    generateThreadTitle: (sourceText: string) => Promise<string>;
 }
 export declare function generateConversationId(prefix: "assistant" | "backfill" | "compaction" | "turn"): string;
 /** Normalize message boundaries without changing transcript formatting. */
@@ -23,6 +22,7 @@ export declare function upsertConversationMessage(conversation: ThreadConversati
 export declare function recordDeliveredAssistantMessage(args: {
     conversation: ThreadConversationState;
     sessionId: string;
+    source?: "web";
     text: string;
     userMessageId?: string;
 }): string;
@@ -39,7 +39,7 @@ export declare function buildConversationContext(conversation: ThreadConversatio
 }): string | undefined;
 /** Return the earliest human-authored message known for a thread. */
 export declare function getThreadTitleSourceMessage(conversation: ThreadConversationState): ConversationMessage | undefined;
-/** Build the service that owns durable conversation memory compaction and titles. */
+/** Build the service that owns durable conversation memory compaction. */
 export declare function createConversationMemoryService(deps: ConversationMemoryDeps): ConversationMemoryService;
 export declare function isHumanConversationMessage(message: ConversationMessage): boolean;
 /** Return the native Slack timestamp for a persisted conversation message. */

package/dist/chat/services/conversation-title.d.ts

@@ -0,0 +1,20 @@
+import type { ConversationStore } from "@/chat/conversations/store";
+import type { ThreadConversationState } from "@/chat/state/conversation";
+/** Test-only: clear in-flight title work between cases. */
+export declare function resetConversationTitleStateForTests(): void;
+/**
+ * Fire-and-forget title work after durable human transcript writes.
+ * This is the only entry that starts generation.
+ */
+export declare function scheduleConversationTitle(args: {
+    conversation: ThreadConversationState;
+    conversationId: string | undefined;
+}): void;
+/**
+ * Join in-flight generation when present, otherwise read the stored title.
+ * Does not start generation; providers use this only to project a title.
+ */
+export declare function resolveConversationTitle(args: {
+    conversationId: string;
+    conversationStore?: Pick<ConversationStore, "get">;
+}): Promise<string | undefined>;