@sentry/junior 0.93.0 → 0.95.0

package/dist/chat/conversations/visible-messages.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Visible-transcript sync between the in-memory turn working set and SQL.
+ *
+ * The durable authority for the visible conversation transcript is the
+ * `ConversationMessageStore`; `ThreadConversationState.messages` is only the
+ * in-memory working set for the current turn. These helpers hydrate that
+ * working set from SQL at load boundaries and write new/updated messages back
+ * through the store, so no transcript data is persisted to `thread-state`.
+ */
+import type { NewConversationMessage } from "@/chat/conversations/messages";
+import type { ConversationMessage, ThreadConversationState } from "@/chat/state/conversation";
+/**
+ * Project the in-memory message onto the store insert shape. This is the single
+ * serialization point for visible messages, so both live turn persistence and
+ * the one-time legacy import produce identical rows: author display facts and
+ * bounded source meta ride in the `meta` JSON so the working set rehydrates with
+ * identical rendering, and `replied === true` is not stored in meta because
+ * `replied_at` is its authority.
+ */
+export declare function toStoredConversationMessage(message: ConversationMessage): NewConversationMessage;
+/**
+ * Replace the in-memory working set with the durable transcript from SQL,
+ * excluding messages already folded into a thread-state compaction summary.
+ *
+ * Hydrate is a first-read boundary, so it must trigger the once-only Redis→SQL
+ * lazy import before reading SQL: consumers that hydrate before any step
+ * projection read (turn-dedupe, delivered-message redelivery guards,
+ * channel-context assembly) would otherwise make correctness decisions on an
+ * empty transcript for promotion-window stragglers whose history is still only
+ * in legacy Redis. The import is idempotent (skips when SQL step rows exist)
+ * and no-ops cheaply when there is nothing legacy to read.
+ */
+export declare function hydrateConversationMessages(args: {
+    conversation: ThreadConversationState;
+    conversationId: string | undefined;
+}): Promise<void>;
+/**
+ * Write the working set back to SQL: record every message idempotently and set
+ * the `replied_at` mark for messages the turn has answered. Content columns are
+ * insert-only and `meta` merges key-wise on conflict, so repeated calls across
+ * a turn's persist points are safe.
+ */
+export declare function persistConversationMessages(args: {
+    conversation: ThreadConversationState;
+    conversationId: string | undefined;
+    repliedAtMs?: number;
+}): Promise<void>;

package/dist/chat/db.d.ts

@@ -1,8 +1,19 @@
 import type { ConversationStore } from "@/chat/conversations/store";
-import type { JuniorDatabase } from "@/chat/sql/db";
+import type { AgentStepStore } from "@/chat/conversations/history";
+import type { ConversationMessageStore } from "@/chat/conversations/messages";
+import type { JuniorDatabase, JuniorSqlExecutor } from "@/db/db";
+/**
+ * Return the process SQL executor. Exposed for the one-time legacy import
+ * writer, which needs explicit-`seq`/epoch inserts the step-store port omits.
+ */
+export declare function getSqlExecutor(): JuniorSqlExecutor;
 /** Return the process Drizzle database. */
 export declare function getDb(): JuniorDatabase;
 /** Return the SQL-backed conversation store. */
 export declare function getConversationStore(): ConversationStore;
+/** Return the SQL-backed durable agent step store. */
+export declare function getAgentStepStore(): AgentStepStore;
+/** Return the SQL-backed visible conversation message store. */
+export declare function getConversationMessageStore(): ConversationMessageStore;
 /** Close the process SQL database when it has been opened. */
 export declare function closeDb(): Promise<void>;

package/dist/chat/egress/credentialed.d.ts

@@ -15,7 +15,7 @@ export type CredentialedEgressHttpInterceptor = (input: {
 }) => Promise<Response | undefined>;
 /** Runtime dependencies for the credentialed provider forwarding step. */
 export interface CredentialedEgressDeps {
-    clearCredentialLease?: (provider: string, grantName: string, credentialContext: SandboxEgressCredentialContext) => Promise<void>;
+    clearCredentialLease?: (provider: string, grant: SandboxEgressCredentialLease["grant"], credentialContext: SandboxEgressCredentialContext) => Promise<void>;
     fetch?: typeof fetch;
     issueCredentialLease?: (provider: string, selection: SandboxEgressGrantSelection, credentialContext: SandboxEgressCredentialContext) => Promise<SandboxEgressCredentialLease>;
     interceptHttp?: CredentialedEgressHttpInterceptor;

package/dist/chat/identities/sql.d.ts

@@ -1,4 +1,4 @@
-import type { JuniorSqlDatabase } from "@/chat/sql/db";
+import type { JuniorSqlDatabase } from "@/db/db";
 import { type IdentityUpsert, type StoredIdentity } from "./identity";
 /** Persist one provider identity observation and link verified emails to users. */
 export declare function upsertIdentity(executor: JuniorSqlDatabase, identity: IdentityUpsert, nowMs?: number): Promise<StoredIdentity>;

package/dist/chat/logging.d.ts

@@ -62,6 +62,7 @@ export declare function setSentryTagsFromContext(context: LogContext): void;
 export declare function setSentryUser(identity: SentryUserIdentity | undefined): void;
 /** Attach scoped Sentry context for isolated exception capture. */
 export declare function setSentryScopeContext(scope: Sentry.Scope, context: LogContext): void;
+export type SetSpanAttributes = (attributes: Record<string, unknown>) => void;
 /** Capture an error to Sentry and emit an error log record. */
 export declare function captureException(error: unknown, context?: LogContext): void;
 /** Log an info-level structured event. */
@@ -79,7 +80,7 @@ export declare function createRequestContext(request: Request, context?: Partial
 /** Run a callback within a scoped log context. */
 export declare function withContext<T>(context: LogContext, callback: () => Promise<T>): Promise<T>;
 /** Run a callback within a Sentry span and scoped log context. */
-export declare function withSpan<T>(name: string, op: string, context: LogContext, callback: () => Promise<T>, attributes?: Record<string, unknown>): Promise<T>;
+export declare function withSpan<T>(name: string, op: string, context: LogContext, callback: (setSpanAttributes: SetSpanAttributes) => Promise<T>, attributes?: Record<string, unknown>): Promise<T>;
 /** Return Sentry-standard trace propagation headers for the active span. */
 export declare function getTracePropagationHeaders(): TracePropagationHeaders;
 /** Set attributes on the currently active Sentry span. */

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

@@ -21,9 +21,9 @@ declare const subscriptionSchema: z.ZodObject<{
     resourceRef: z.ZodString;
     resourceType: z.ZodString;
     status: z.ZodEnum<{
+        cancelled: "cancelled";
         completed: "completed";
         active: "active";
-        cancelled: "cancelled";
     }>;
     updatedAtMs: z.ZodNumber;
 }, z.core.$strict>;
@@ -75,5 +75,6 @@ export declare function deliverResourceEventSubscription(input: {
     state?: StateAdapter;
     subscription: ResourceEventSubscription;
     terminal?: boolean;
+    waitDeadlineMs?: number;
 }): Promise<boolean>;
 export {};

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

@@ -1,3 +1,11 @@
+/**
+ * Slack reply execution boundary.
+ *
+ * This module bridges prepared Slack thread state into the agent runner
+ * and commits the resulting Slack-visible delivery/state updates. It is where
+ * queued messages, compaction, status updates, and Slack posting meet; agent
+ * internals stay behind the runner seam.
+ */
 import type { Message, Thread } from "chat";
 import type { SlackAdapter } from "@chat-adapter/slack";
 import { type Destination } from "@sentry/junior-plugin-api";

package/dist/chat/runtime/thread-state.d.ts

@@ -17,6 +17,8 @@ export declare function mergeArtifactsState(artifacts: ThreadArtifactsState, pat
 export declare function getPersistedSandboxState(state: Record<string, unknown>): PersistedSandboxState;
 /** Persist a thread-state patch through the Chat SDK thread interface. */
 export declare function persistThreadState(thread: Thread, patch: ThreadStatePatch): Promise<void>;
+/** Persist only the Redis-backed runtime scratch in a thread-state patch. */
+export declare function persistThreadRuntimeState(thread: Thread, patch: ThreadStatePatch): Promise<void>;
 /** Load the persisted state payload for a thread without requiring a Chat singleton. */
 export declare function getPersistedThreadState(threadId: string): Promise<Record<string, unknown>>;
 /** Load the persisted state payload for a channel without constructing a Chat channel. */

package/dist/chat/sandbox/egress/schemas.d.ts

@@ -1,6 +1,7 @@
 import { z } from "zod";
 export declare const sandboxEgressGrantSchema: z.ZodObject<{
     access: z.ZodUnion<readonly [z.ZodLiteral<"read">, z.ZodLiteral<"write">]>;
+    leaseScope: z.ZodOptional<z.ZodString>;
     name: z.ZodString;
     reason: z.ZodOptional<z.ZodString>;
     requirements: z.ZodOptional<z.ZodArray<z.ZodString>>;
@@ -45,6 +46,7 @@ export declare const sandboxEgressCredentialLeaseSchema: z.ZodObject<{
     }, z.core.$strict>>;
     grant: z.ZodObject<{
         access: z.ZodUnion<readonly [z.ZodLiteral<"read">, z.ZodLiteral<"write">]>;
+        leaseScope: z.ZodOptional<z.ZodString>;
         name: z.ZodString;
         reason: z.ZodOptional<z.ZodString>;
         requirements: z.ZodOptional<z.ZodArray<z.ZodString>>;
@@ -64,6 +66,7 @@ export declare const sandboxEgressAuthRequiredSignalSchema: z.ZodObject<{
     }, z.core.$strict>>;
     grant: z.ZodObject<{
         access: z.ZodUnion<readonly [z.ZodLiteral<"read">, z.ZodLiteral<"write">]>;
+        leaseScope: z.ZodOptional<z.ZodString>;
         name: z.ZodString;
         reason: z.ZodOptional<z.ZodString>;
         requirements: z.ZodOptional<z.ZodArray<z.ZodString>>;
@@ -85,6 +88,7 @@ export declare const sandboxEgressPermissionDeniedSignalSchema: z.ZodObject<{
     acceptedPermissions: z.ZodOptional<z.ZodString>;
     grant: z.ZodObject<{
         access: z.ZodUnion<readonly [z.ZodLiteral<"read">, z.ZodLiteral<"write">]>;
+        leaseScope: z.ZodOptional<z.ZodString>;
         name: z.ZodString;
         reason: z.ZodOptional<z.ZodString>;
         requirements: z.ZodOptional<z.ZodArray<z.ZodString>>;

package/dist/chat/sandbox/egress/session.d.ts

@@ -31,9 +31,9 @@ export declare function setSandboxEgressCredentialLease(context: SandboxEgressCr
 /**
  * Load cached credential header transforms for the exact actor/context/grant.
  */
-export declare function getSandboxEgressCredentialLease(provider: string, grantName: string, context: SandboxEgressCredentialContext): Promise<SandboxEgressCredentialLease | undefined>;
+export declare function getSandboxEgressCredentialLease(provider: string, grant: SandboxEgressCredentialLease["grant"], context: SandboxEgressCredentialContext): Promise<SandboxEgressCredentialLease | undefined>;
 /** Clear a cached lease after the upstream provider rejects its auth headers. */
-export declare function clearSandboxEgressCredentialLease(provider: string, grantName: string, context: SandboxEgressCredentialContext): Promise<void>;
+export declare function clearSandboxEgressCredentialLease(provider: string, grant: SandboxEgressCredentialLease["grant"], context: SandboxEgressCredentialContext): Promise<void>;
 /**
  * Record that credential issuance needs user authorization for this command.
  *

package/dist/chat/sandbox/resources.d.ts

@@ -0,0 +1,4 @@
+/** Resolve optional resource sizing shared by every newly created sandbox. */
+export declare function getSandboxResources(): {
+    vcpus: number;
+} | undefined;

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

@@ -1,3 +1,11 @@
+/**
+ * MCP authorization pause orchestration.
+ *
+ * This module turns an MCP client auth challenge into Junior's paused-run
+ * model: create provider auth state, deliver or reuse a private Slack link,
+ * record pending auth, and abort the agent so the OAuth callback can resume the
+ * same session.
+ */
 import type { OAuthClientProvider } from "@modelcontextprotocol/sdk/client/auth.js";
 import type { Destination, Source } from "@sentry/junior-plugin-api";
 import { AuthorizationPauseError, type AuthorizationFlowMode } from "@/chat/services/auth-pause";

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

@@ -1,3 +1,15 @@
+/**
+ * Plugin authorization pause orchestration.
+ *
+ * This module detects plugin credential failures from the sandbox egress layer
+ * and maps them onto the same paused-run contract used by MCP auth. It owns
+ * provider attribution, private-link delivery/reuse, session-log recording,
+ * and credential cleanup.
+ *
+ * Auth failures are detected exclusively through the structured `auth_required`
+ * signal emitted by the egress proxy — never inferred from bash command text,
+ * stdout patterns, or exit codes.
+ */
 import type { Destination, Source } from "@sentry/junior-plugin-api";
 import type { ChannelConfigurationService } from "@/chat/configuration/types";
 import type { UserTokenStore } from "@/chat/credentials/user-token-store";

package/dist/chat/services/turn-session-record.d.ts

@@ -38,7 +38,9 @@ export declare function persistRunningSessionRecord(args: {
     trailingMessageProvenance?: PiMessageProvenance[];
     loadedSkillNames?: string[];
     logContext: SessionRecordLogContext;
+    modelId?: string;
     actor?: Actor;
+    reasoningLevel?: string;
     surface?: AgentTurnSurface;
     turnStartMessageIndex?: number;
 }): Promise<boolean>;
@@ -47,8 +49,9 @@ export declare function persistRunningSessionRecord(args: {
  *
  * Generation completing is not delivery: call this only after the destination
  * accepted the visible final reply, so an undelivered assistant reply never
- * becomes durable conversation history or a terminal completed state. Failures
- * are logged and swallowed because the reply is already user-visible.
+ * becomes durable conversation history or a terminal completed state. The
+ * write is retried because the reply is already user-visible, then any remaining
+ * failure surfaces to the post-delivery boundary for one authoritative error.
  */
 export declare function persistCompletedSessionRecord(args: {
     channelName?: string;
@@ -65,7 +68,9 @@ export declare function persistCompletedSessionRecord(args: {
     allMessages: PiMessage[];
     loadedSkillNames?: string[];
     logContext: SessionRecordLogContext;
+    modelId?: string;
     actor?: Actor;
+    reasoningLevel?: string;
     surface?: AgentTurnSurface;
     turnStartMessageIndex?: number;
 }): Promise<void>;
@@ -80,6 +85,7 @@ export declare function completeDeliveredTurn(args: {
     logContext: SessionRecordLogContext;
     messages: PiMessage[];
     actor?: Actor;
+    reasoningLevel?: string;
     sessionId: string;
     sliceId: number;
     source: Source;
@@ -102,9 +108,11 @@ export declare function persistAuthPauseSessionRecord(args: {
     source?: Source;
     messages: PiMessage[];
     loadedSkillNames?: string[];
+    modelId?: string;
     errorMessage: string;
     logContext: SessionRecordLogContext;
     actor?: Actor;
+    reasoningLevel?: string;
     surface?: AgentTurnSurface;
 }): Promise<AgentTurnSessionRecord | undefined>;
 /**
@@ -122,9 +130,11 @@ export declare function persistTimeoutSessionRecord(args: {
     source?: Source;
     messages: PiMessage[];
     loadedSkillNames?: string[];
+    modelId?: string;
     errorMessage: string;
     logContext: SessionRecordLogContext;
     actor?: Actor;
+    reasoningLevel?: string;
     surface?: AgentTurnSurface;
 }): Promise<AgentTurnSessionRecord | undefined>;
 /**
@@ -141,9 +151,11 @@ export declare function persistYieldSessionRecord(args: {
     source?: Source;
     messages: PiMessage[];
     loadedSkillNames?: string[];
+    modelId?: string;
     errorMessage: string;
     logContext: SessionRecordLogContext;
     actor?: Actor;
+    reasoningLevel?: string;
     surface?: AgentTurnSurface;
 }): Promise<AgentTurnSessionRecord | undefined>;
 export {};

package/dist/chat/sleep.d.ts

@@ -0,0 +1,2 @@
+/** Wait for a duration, rejecting with the owning signal reason when cancelled. */
+export declare function sleep(ms: number, signal?: AbortSignal): Promise<void>;

package/dist/chat/state/conversation.d.ts

@@ -1,4 +1,3 @@
-import type { PiMessage } from "@/chat/pi/messages";
 import type { AuthorizationPauseKind } from "@/chat/services/auth-pause";
 type ConversationRole = "assistant" | "system" | "user";
 export interface ConversationAuthor {
@@ -66,7 +65,6 @@ export interface ThreadConversationState {
     backfill: ConversationBackfillState;
     compactions: ConversationCompaction[];
     messages: ConversationMessage[];
-    piMessages: PiMessage[];
     processing: ConversationProcessingState;
     schemaVersion: 1;
     stats: ConversationStats;
@@ -74,8 +72,13 @@ export interface ThreadConversationState {
 }
 /** Safely coerce an unknown persisted value into a ThreadConversationState. */
 export declare function coerceThreadConversationState(value: unknown): ThreadConversationState;
-/** Wrap a conversation state into the storage envelope for persistence. */
+/**
+ * Wrap a conversation state into the storage envelope for persistence. The
+ * visible transcript (`messages`) is not written to `thread-state`; it lives
+ * in SQL (`ConversationMessageStore`), and Pi history lives in the SQL
+ * `AgentStepStore`. Only runtime scratch is persisted here.
+ */
 export declare function buildConversationStatePatch(conversation: ThreadConversationState): {
-    conversation: ThreadConversationState;
+    conversation: Omit<ThreadConversationState, "compactions" | "messages">;
 };
 export {};

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

@@ -3,7 +3,8 @@ import { type Actor } from "@sentry/junior-plugin-api";
 import { type PiMessage } from "@/chat/pi/messages";
 import { type StoredSlackActor } from "@/chat/actor";
 declare const piMessageAuthoritySchema: z.ZodUnion<readonly [z.ZodLiteral<"instruction">, z.ZodLiteral<"context">]>;
-declare const piMessageProvenanceSchema: z.ZodObject<{
+/** Per-message provenance payload reused by the SQL agent-step envelope. */
+export declare const piMessageProvenanceSchema: z.ZodObject<{
     authority: z.ZodUnion<readonly [z.ZodLiteral<"instruction">, z.ZodLiteral<"context">]>;
     actor: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
         platform: z.ZodLiteral<"slack">;
@@ -27,6 +28,13 @@ declare const piMessageProvenanceSchema: z.ZodObject<{
 export type PiMessageAuthority = z.output<typeof piMessageAuthoritySchema>;
 /** Per-message record of the actor a Pi message came from and its authority weight. */
 export type PiMessageProvenance = z.output<typeof piMessageProvenanceSchema>;
+/**
+ * Recover per-message provenance from a legacy v1 pi_message. A stored Slack
+ * actor on the entry meant that user message was the turn instruction, so it
+ * decodes to an authored instruction when the identity is intact; anything
+ * missing or malformed fails closed to unauthored context.
+ */
+export declare function legacyActorProvenance(actor: StoredSlackActor): PiMessageProvenance;
 declare const authorizationKindSchema: z.ZodUnion<readonly [z.ZodLiteral<"plugin">, z.ZodLiteral<"mcp">]>;
 declare const transcriptRefSchema: z.ZodObject<{
     type: z.ZodLiteral<"advisor_session">;
@@ -168,6 +176,8 @@ declare const sessionLogEntrySchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
         key: z.ZodString;
     }, z.core.$strip>;
     historyMode: z.ZodLiteral<"shared">;
+    modelId: z.ZodOptional<z.ZodString>;
+    reasoningLevel: z.ZodOptional<z.ZodString>;
     createdAtMs: z.ZodNumber;
 }, z.core.$strip>, z.ZodObject<{
     schemaVersion: z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>]>;
@@ -218,6 +228,16 @@ export interface SessionProjection {
  * distinctness is by identity ids only, never display fields.
  */
 export declare function instructionActors(provenance: PiMessageProvenance[]): Actor[];
+/**
+ * Read the raw decoded legacy session-log entries for one conversation.
+ *
+ * The single read source for the one-time Redis→SQL history import; it returns
+ * every entry in list order (no projection collapsing) so the importer can
+ * translate `sessionId` markers into context epochs.
+ */
+export declare function readSessionLogEntries(args: Scope & {
+    store?: SessionLogStore;
+}): Promise<SessionLogEntry[]>;
 /** Load chronological host-only runtime activity entries for reporting. */
 export declare function loadActivityEntries(args: Scope & {
     store?: SessionLogStore;
@@ -304,9 +324,11 @@ export declare function recordToolExecutionStarted(args: Scope & {
 export declare function recordSubagentStarted(args: Scope & {
     createdAtMs?: number;
     historyMode: "shared";
+    modelId?: string;
     parentConversationId: string;
     parentSessionId?: string;
     parentToolCallId?: string;
+    reasoningLevel?: string;
     sessionId?: string;
     store?: SessionLogStore;
     subagentInvocationId: string;

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

@@ -19,6 +19,8 @@ export interface AgentTurnSessionRecord {
     errorMessage?: string;
     lastProgressAtMs: number;
     loadedSkillNames?: string[];
+    modelId?: string;
+    reasoningLevel?: string;
     piMessages: PiMessage[];
     /** Per-message provenance aligned one-to-one with `piMessages`. */
     piMessageProvenance: PiMessageProvenance[];
@@ -57,6 +59,7 @@ export declare function upsertAgentTurnSessionRecord(args: {
     source?: Source;
     lastProgressAtMs?: number;
     loadedSkillNames?: string[];
+    modelId?: string;
     conversationStore?: ConversationStore;
     sessionId: string;
     sliceId: number;
@@ -67,6 +70,7 @@ export declare function upsertAgentTurnSessionRecord(args: {
     trailingMessageProvenance?: PiMessageProvenance[];
     actor?: Actor;
     resumeReason?: AgentTurnResumeReason;
+    reasoningLevel?: string;
     errorMessage?: string;
     resumedFromSliceId?: number;
     traceId?: string;
@@ -89,9 +93,11 @@ export declare function recordAgentTurnSessionSummary(args: {
     source?: Source;
     lastProgressAtMs?: number;
     loadedSkillNames?: string[];
+    modelId?: string;
     conversationStore?: ConversationStore;
     actor?: Actor;
     resumeReason?: AgentTurnResumeReason;
+    reasoningLevel?: string;
     sessionId: string;
     sliceId: number;
     startedAtMs?: number;

package/dist/chat/tool-support/private-trace-result.d.ts

@@ -0,0 +1,4 @@
+/** Mark one tool result as an adapter-approved private trace projection. */
+export declare function privateTraceResultAttributes(): Record<string, string>;
+/** Consume and remove the adapter-owned private trace projection marker. */
+export declare function consumePrivateTraceResultMarker(attributes: Record<string, unknown>): boolean;

package/dist/chat/tool-support/zod-tool.d.ts

@@ -13,6 +13,7 @@ export interface ContentOnlyToolResult {
 }
 type StructuredZodToolDefinition<TInputSchema extends ZodTypeAny, TOutputSchema extends ZodType<JuniorToolResult>> = ZodToolDefinitionBase<TInputSchema> & {
     outputSchema: TOutputSchema;
+    privateTraceResult?(result: z.output<TOutputSchema>): unknown;
     execute?: (input: z.output<TInputSchema>, options: ToolExecuteOptions) => Promise<StructuredToolExecuteResult<TOutputSchema>> | StructuredToolExecuteResult<TOutputSchema>;
 };
 type ContentZodToolDefinition<TInputSchema extends ZodTypeAny> = ZodToolDefinitionBase<TInputSchema> & {

package/dist/chat/tools/advisor/tool.d.ts

@@ -2,7 +2,7 @@ import { type AgentTool, type StreamFn } from "@earendil-works/pi-agent-core";
 import type { AdvisorConfig } from "@/chat/config";
 import { type ConversationPrivacy } from "@/chat/conversation-privacy";
 import { type LogContext } from "@/chat/logging";
-import { type AdvisorSessionStore } from "@/chat/tools/advisor/session-store";
+import type { ConversationStore } from "@/chat/conversations/store";
 import type { AnyToolDefinition } from "@/chat/tools/definition";
 export type AdvisorErrorCode = "invalid_context" | "invalid_question" | "missing_conversation_id" | "session_unavailable" | "unavailable";
 export type AdvisorToolResult = {
@@ -17,13 +17,18 @@ export interface AdvisorToolRuntimeContext {
     conversationPrivacy?: ConversationPrivacy;
     getTools: () => AgentTool[];
     logContext?: LogContext;
-    parentSessionId?: string;
-    store?: AdvisorSessionStore;
+    /** Metadata store used to link the advisor child conversation to its parent. */
+    conversationStore?: ConversationStore;
     streamFn?: StreamFn;
 }
+/**
+ * Deterministic advisor child conversation id derived from the parent so
+ * repeated advisor calls in one parent conversation append to the same history.
+ */
+export declare function advisorChildConversationId(parentConversationId: string): string;
 /** Build the advisor's read-only tool definition subset. */
 export declare function createAdvisorToolDefinitions(definitions: Record<string, AnyToolDefinition>): Record<string, AnyToolDefinition>;
-/** Create the advisor tool backed by conversation-scoped message history. */
+/** Create the advisor tool backed by a child-conversation message history. */
 export declare function createAdvisorTool(context: AdvisorToolRuntimeContext): Omit<AnyToolDefinition, "inputSchema" | "outputSchema" | "prepareArguments" | "execute"> & {
     inputSchema: import("@/chat/tools/definition").JsonSchemaObject;
     outputSchema: import("@/chat/tools/definition").JsonSchemaObject;

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

@@ -32,6 +32,7 @@ interface BaseToolDefinition<TInput, TInputSchema extends ToolInputSchema> {
     exposure?: ToolExposure;
     inputSchema: TInputSchema;
     outputSchema?: ToolInputSchema;
+    privateTraceResult?(result: unknown): unknown;
     annotations?: ToolAnnotations;
     /**
      * @deprecated Put tool-selection and usage guidance directly in `description`
@@ -70,6 +71,7 @@ export interface AnyToolDefinition {
     exposure?: ToolExposure;
     inputSchema: ToolInputSchema;
     outputSchema?: ToolInputSchema;
+    privateTraceResult?(result: unknown): unknown;
     annotations?: ToolAnnotations;
     /**
      * @deprecated Put tool-selection and usage guidance directly in `description`

package/dist/chat/tools/execution/tool-error-handler.d.ts

@@ -1,4 +1,4 @@
-import { type LogContext } from "@/chat/logging";
+import { type LogContext, type SetSpanAttributes } from "@/chat/logging";
 import type { ConversationPrivacy } from "@/chat/conversation-privacy";
 /** Handle tool execution errors: set span attributes, log, and rethrow. */
-export declare function handleToolExecutionError(error: unknown, toolName: string, toolCallId: string | undefined, shouldTrace: boolean, traceContext: LogContext, conversationPrivacy?: ConversationPrivacy): never;
+export declare function handleToolExecutionError(error: unknown, toolName: string, toolCallId: string | undefined, shouldTrace: boolean, traceContext: LogContext, conversationPrivacy?: ConversationPrivacy, setExecutionSpanAttributes?: SetSpanAttributes): never;

package/dist/chat/tools/system-time.d.ts

@@ -6,6 +6,10 @@ export declare function createSystemTimeTool(): Omit<import("./definition").AnyT
         [x: string]: unknown;
         ok: boolean;
         status: "error" | "success";
+        unix_ms: number;
+        iso_utc: string;
+        iso_local: string;
+        timezone_offset_minutes: number;
         target?: string | undefined;
         data?: unknown;
         truncated?: boolean | undefined;
@@ -22,6 +26,10 @@ export declare function createSystemTimeTool(): Omit<import("./definition").AnyT
         [x: string]: unknown;
         ok: boolean;
         status: "error" | "success";
+        unix_ms: number;
+        iso_utc: string;
+        iso_local: string;
+        timezone_offset_minutes: number;
         target?: string | undefined;
         data?: unknown;
         truncated?: boolean | undefined;

package/dist/chat/xml.d.ts

@@ -1 +1,3 @@
 export declare function escapeXml(value: string): string;
+/** Recover text escaped for an internal XML prompt boundary. */
+export declare function unescapeXml(value: string): string;

package/dist/{chunk-NYWPISSO.js → chunk-2XXEKR44.js}

@@ -4,7 +4,7 @@ import {
 import {
   destinationKey,
   parseDestination
-} from "./chunk-GHGPTPBL.js";
+} from "./chunk-B7PUBQQM.js";
 
 // src/chat/task-execution/queue-signing.ts
 import { createHmac, timingSafeEqual } from "crypto";

package/dist/{chunk-QGEWC27H.js → chunk-5XMNOD3S.js}

@@ -1,20 +1,18 @@
 import {
   JUNIOR_THREAD_STATE_TTL_MS
-} from "./chunk-PFXC67GJ.js";
+} from "./chunk-CRRBJ3JP.js";
 import {
+  getChatConfig,
   getDefaultRedisStateAdapterFor,
   getStateAdapter
-} from "./chunk-7STN2ZSK.js";
-import {
-  getChatConfig
-} from "./chunk-NAPITCZ6.js";
+} from "./chunk-GUE7HTNR.js";
 import {
   parseDestination,
   sameDestination
-} from "./chunk-GHGPTPBL.js";
+} from "./chunk-B7PUBQQM.js";
 import {
   parseStoredSlackActor
-} from "./chunk-S6QKIGRM.js";
+} from "./chunk-WPOJ443W.js";
 import {
   isRecord,
   toOptionalNumber,