@sentry/junior 0.94.0 → 0.96.0

package/dist/{catalog-runtime-NZHMSMYC.js → catalog-runtime-MSMAYYIK.js}

@@ -1,11 +1,11 @@
 import {
   pluginCatalogRuntime
-} from "./chunk-BTH37NCU.js";
-import "./chunk-S6QKIGRM.js";
+} from "./chunk-L7CDEIVJ.js";
+import "./chunk-I35CTGPO.js";
 import "./chunk-OB42YVAE.js";
-import "./chunk-3DA7X2U3.js";
+import "./chunk-6GWA276C.js";
 import "./chunk-6APU57E6.js";
-import "./chunk-LFLTJQVR.js";
+import "./chunk-7FBGKXPE.js";
 import "./chunk-MLKGABMK.js";
 export {
   pluginCatalogRuntime

package/dist/chat/advisor-request.d.ts

@@ -0,0 +1,4 @@
+/** Render the executor's advisor request in stable model-facing boundaries. */
+export declare function renderAdvisorRequest(question: string, context: string): string;
+/** Recover readable task and context text from an advisor request message. */
+export declare function unwrapAdvisorRequest(text: string): string | undefined;

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

@@ -86,6 +86,8 @@ export interface AgentRunRouting {
 export interface AgentRunPolicy {
     /** Absolute wall-clock deadline for this host request, in milliseconds. */
     turnDeadlineAtMs?: number;
+    /** Cancels provider work when the owning host request is abandoned. */
+    signal?: AbortSignal;
     authorizationFlowMode?: AuthorizationFlowMode;
     configuration?: Record<string, unknown>;
     channelConfiguration?: ChannelConfigurationService;

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

@@ -25,6 +25,8 @@ interface ResumeStateArgs {
     durability: AgentRunDurability;
     getLoadedSkillNames: () => string[];
     logContext: SessionRecordLogContext;
+    modelId: string;
+    getReasoningLevel: () => string | undefined;
     recordActiveMcpProviders: () => Promise<void>;
     actor?: Actor;
     runSource: Source;

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

@@ -0,0 +1,128 @@
+/**
+ * Durable agent execution history port.
+ *
+ * Steps are appended one row at a time under the conversation lease; context
+ * rebuilds (compaction/rollback) open a new epoch instead of rewriting history.
+ * The step envelope is strictly validated — an unknown type or malformed shape
+ * is corrupt state and fails loudly — while `pi_message` content stays
+ * permissive because the Pi SDK owns the message shape.
+ */
+import { z } from "zod";
+import { type PiMessage } from "@/chat/pi/messages";
+import { type PiMessageProvenance } from "@/chat/state/session-log";
+/** Reason a new context epoch was opened. */
+export type EpochReason = "compaction" | "rollback";
+/** Strict step envelope reused by the SQL row codec; unknown types fail loudly. */
+export declare const agentStepEntrySchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"pi_message">;
+    schemaVersion: z.ZodOptional<z.ZodNumber>;
+    message: z.ZodPipe<z.ZodObject<{
+        role: z.ZodString;
+    }, z.core.$loose>, z.ZodTransform<import("@earendil-works/pi-ai").AssistantMessage | import("@earendil-works/pi-ai").UserMessage | import("@earendil-works/pi-ai").ToolResultMessage<any> | import("@earendil-works/pi-agent-core").CustomMessage<unknown> | import("@earendil-works/pi-agent-core").BashExecutionMessage | import("@earendil-works/pi-agent-core").BranchSummaryMessage | import("@earendil-works/pi-agent-core").CompactionSummaryMessage, {
+        [x: string]: unknown;
+        role: string;
+    }>>;
+    provenance: z.ZodOptional<z.ZodObject<{
+        authority: z.ZodUnion<readonly [z.ZodLiteral<"instruction">, z.ZodLiteral<"context">]>;
+        actor: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            platform: z.ZodLiteral<"slack">;
+            teamId: z.ZodString;
+            email: z.ZodOptional<z.ZodString>;
+            fullName: z.ZodOptional<z.ZodString>;
+            userId: z.ZodString;
+            userName: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>, z.ZodObject<{
+            platform: z.ZodLiteral<"local">;
+            email: z.ZodOptional<z.ZodString>;
+            fullName: z.ZodOptional<z.ZodString>;
+            userId: z.ZodString;
+            userName: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>, z.ZodObject<{
+            platform: z.ZodLiteral<"system">;
+            name: z.ZodString;
+        }, z.core.$strict>], "platform">>;
+    }, z.core.$strict>>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"context_epoch_started">;
+    reason: z.ZodUnion<readonly [z.ZodLiteral<"compaction">, z.ZodLiteral<"rollback">]>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"mcp_provider_connected">;
+    provider: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"authorization_requested">;
+    kind: z.ZodUnion<readonly [z.ZodLiteral<"plugin">, z.ZodLiteral<"mcp">]>;
+    provider: z.ZodString;
+    actorId: z.ZodString;
+    authorizationId: z.ZodString;
+    delivery: z.ZodUnion<readonly [z.ZodLiteral<"private_link_sent">, z.ZodLiteral<"private_link_reused">]>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"authorization_completed">;
+    kind: z.ZodUnion<readonly [z.ZodLiteral<"plugin">, z.ZodLiteral<"mcp">]>;
+    provider: z.ZodString;
+    actorId: z.ZodString;
+    authorizationId: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"tool_execution_started">;
+    toolCallId: z.ZodString;
+    toolName: z.ZodString;
+    args: z.ZodOptional<z.ZodUnknown>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"visible_context_compacted">;
+    compactions: z.ZodArray<z.ZodObject<{
+        coveredMessageIds: z.ZodArray<z.ZodString>;
+        createdAtMs: z.ZodNumber;
+        id: z.ZodString;
+        summary: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"subagent_started">;
+    subagentInvocationId: z.ZodString;
+    subagentKind: z.ZodString;
+    modelId: z.ZodOptional<z.ZodString>;
+    parentToolCallId: z.ZodOptional<z.ZodString>;
+    reasoningLevel: z.ZodOptional<z.ZodString>;
+    childConversationId: z.ZodString;
+    historyMode: z.ZodLiteral<"shared">;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"subagent_ended">;
+    subagentInvocationId: z.ZodString;
+    outcome: z.ZodUnion<readonly [z.ZodLiteral<"success">, z.ZodLiteral<"error">, z.ZodLiteral<"aborted">]>;
+    errorCode: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>], "type">;
+/** One durable execution step's validated payload (sessionId lifted to epoch). */
+export type AgentStepEntry = z.infer<typeof agentStepEntrySchema>;
+/** A step read back from storage with its assigned order and epoch. */
+export interface StoredAgentStep {
+    seq: number;
+    contextEpoch: number;
+    createdAtMs: number;
+    entry: AgentStepEntry;
+}
+/** A step to append; the store assigns `seq` and the current `context_epoch`. */
+export interface NewAgentStep {
+    entry: AgentStepEntry;
+    createdAtMs: number;
+}
+/** A replacement Pi message written into a freshly opened epoch. */
+export interface PiMessageStep {
+    message: PiMessage;
+    createdAtMs: number;
+    provenance?: PiMessageProvenance;
+}
+/** Persist and read the durable per-conversation agent execution history. */
+export interface AgentStepStore {
+    /** Append steps in one transaction, assigning `seq = max+1` under the lease. */
+    append(conversationId: string, steps: NewAgentStep[]): Promise<void>;
+    /**
+     * Open the next epoch in one transaction: a `context_epoch_started` marker
+     * followed by the replacement messages as ordinary `pi_message` rows.
+     */
+    startEpoch(conversationId: string, opts: {
+        reason: EpochReason;
+        messages: PiMessageStep[];
+    }): Promise<void>;
+    /** Steps of the highest epoch in `seq` order (all types; caller filters). */
+    loadCurrentEpoch(conversationId: string): Promise<StoredAgentStep[]>;
+    /** All steps across all epochs in `seq` order, for audit and reporting. */
+    loadHistory(conversationId: string): Promise<StoredAgentStep[]>;
+}

package/dist/chat/conversations/legacy-import.d.ts

@@ -0,0 +1,38 @@
+import { type ConversationCompaction, type ConversationMessage as ThreadConversationMessage } from "@/chat/state/conversation";
+import { type SessionLogStore } from "@/chat/state/session-log";
+import { type AdvisorSessionStore } from "@/chat/tools/advisor/session-store";
+import type { JuniorSqlDatabase } from "@/db/db";
+import type { ConversationMessageStore } from "./messages";
+import type { Conversation } from "./store";
+/** Legacy source seams used by the one-time migration. */
+export interface LegacyImportDeps {
+    executor: JuniorSqlDatabase;
+    messageStore: ConversationMessageStore;
+    sessionLogStore?: SessionLogStore;
+    advisorSessionStore?: AdvisorSessionStore;
+    loadVisibleMessages?: (conversationId: string) => Promise<ThreadConversationMessage[]>;
+    legacyCompactions?: ConversationCompaction[];
+    /** Conversation metadata used for imported creation and activity clocks. */
+    conversationRecord?: Conversation;
+    /** Latest activity recovered from the legacy thread-state payload. */
+    legacyLastActivityAtMs?: number;
+}
+/**
+ * Import one conversation's legacy Redis history into SQL, idempotently.
+ *
+ * Returns whether an import ran (false when step rows already exist or there is
+ * nothing legacy to import).
+ */
+export declare function importConversationFromLegacy(conversationId: string, deps: LegacyImportDeps): Promise<{
+    imported: boolean;
+}>;
+/**
+ * Lazy first-read import for a straggler the old deployment touched during
+ * promotion. Runs under the conversation lease the worker already holds before
+ * any turn/resume projection read; idempotent skip-if-rows-exist makes re-entry
+ * safe. Missing legacy keys produce empty reads for genuinely new conversations;
+ * actual Redis read failures surface through normal worker recovery.
+ */
+export declare function ensureLegacyConversationImport(args: {
+    conversationId: string;
+}): Promise<void>;

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

@@ -0,0 +1,39 @@
+/**
+ * Visible conversation message port.
+ *
+ * Messages are immutable source facts recorded idempotently by source identity;
+ * the only mutable bookkeeping is the `replied_at` delivery mark.
+ */
+/** Author role of a visible conversation message. */
+export type ConversationMessageRole = "user" | "assistant" | "system";
+/** A source message to record; identity is `(conversationId, messageId)`. */
+export interface NewConversationMessage {
+    messageId: string;
+    role: ConversationMessageRole;
+    text: string;
+    authorIdentityId?: string;
+    meta?: Record<string, unknown>;
+    createdAtMs: number;
+}
+/** A visible message read back from storage. */
+export interface ConversationMessage {
+    conversationId: string;
+    messageId: string;
+    role: ConversationMessageRole;
+    text: string;
+    authorIdentityId?: string;
+    meta?: Record<string, unknown>;
+    repliedAtMs?: number;
+    createdAtMs: number;
+}
+/** Persist and read the visible per-conversation message transcript. */
+export interface ConversationMessageStore {
+    /** Record source messages idempotently by `(conversation_id, message_id)`. */
+    record(conversationId: string, messages: NewConversationMessage[]): Promise<void>;
+    /** Set the mutable `replied_at` mark; content columns are never touched. */
+    markReplied(conversationId: string, messageId: string, repliedAtMs: number): Promise<void>;
+    /** List messages in `created_at` order. */
+    list(conversationId: string, opts?: {
+        limit?: number;
+    }): Promise<ConversationMessage[]>;
+}

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

@@ -0,0 +1,94 @@
+import type { PiMessage } from "@/chat/pi/messages";
+import { type AuthorizationKind, type PiMessageProvenance, type SessionProjection } from "@/chat/state/session-log";
+import type { StoredAgentStep } from "@/chat/conversations/history";
+/** Aligned step projection: `provenance[i]` and `seqs[i]` describe `messages[i]`. */
+export interface StepProjection extends SessionProjection {
+    /** The `seq` of the step each projected message came from. */
+    seqs: number[];
+}
+/**
+ * Materialize Pi messages with aligned provenance and source seqs from one
+ * epoch's steps. Steps above `maxSeq` (when given) are excluded so a terminal
+ * turn record reproduces exactly the boundary it committed.
+ */
+export declare function projectSteps(steps: StoredAgentStep[], opts?: {
+    maxSeq?: number;
+}): StepProjection;
+interface ScopedConversation {
+    conversationId: string;
+}
+/** Load the current-epoch Pi projection for a conversation. */
+export declare function loadProjection(args: ScopedConversation): Promise<PiMessage[]>;
+/** Load the current-epoch Pi projection with aligned per-message provenance. */
+export declare function loadProjectionWithProvenance(args: ScopedConversation): Promise<SessionProjection>;
+/**
+ * Load a turn's committed Pi projection from the durable step store.
+ *
+ * The record stays pinned to the epoch containing its committed boundary, so a
+ * later rollback or compaction cannot silently rewrite what a stale record
+ * resumes from. Unfinished records (`includeTail`) also see that epoch's tail
+ * so parked input appended after the last safe boundary is model-visible; for
+ * a live run the committed epoch is the current epoch. Terminal records
+ * reproduce exactly the boundary they committed by cutting at `committedSeq`.
+ * Returns undefined when the committed boundary no longer exists (purged
+ * history) so callers fail closed.
+ */
+export declare function loadTurnProjection(args: {
+    conversationId: string;
+    committedSeq: number;
+    includeTail: boolean;
+}): Promise<StepProjection | undefined>;
+/** Load MCP providers durably connected in this conversation's current epoch. */
+export declare function loadConnectedMcpProviders(args: ScopedConversation): Promise<string[]>;
+/**
+ * Commit the turn's Pi history: append when it advanced the committed
+ * projection normally, or open a `rollback` epoch when it diverged (a
+ * provider-retry trim regenerated trailing assistant output). Returns the
+ * resolved provenance, the per-message step seqs, and the `seq` boundary that
+ * reproduces exactly the committed messages.
+ */
+export declare function commitMessages(args: {
+    conversationId: string;
+    messages: PiMessage[];
+    /** Explicit per-message provenance aligned one-to-one with `messages`. */
+    provenance?: PiMessageProvenance[];
+    /** Explicit provenance for the trailing newly committed messages. */
+    trailingMessageProvenance?: PiMessageProvenance[];
+    /** Default applied to the last new user message when no explicit array. */
+    newMessageProvenance?: PiMessageProvenance;
+}): Promise<{
+    committedSeq: number;
+    messageSeqs: number[];
+    provenance: PiMessageProvenance[];
+}>;
+/** Record a successful MCP provider connection without duplicating the fact. */
+export declare function recordMcpProviderConnected(args: {
+    conversationId: string;
+    provider: string;
+}): Promise<void>;
+/** Record that an OAuth/MCP authorization link was delivered or reused. */
+export declare function recordAuthorizationRequested(args: {
+    conversationId: string;
+    kind: AuthorizationKind;
+    provider: string;
+    actorId: string;
+    authorizationId: string;
+    delivery: "private_link_sent" | "private_link_reused";
+}): Promise<void>;
+/** Record completed authorization as a chronological host observation for Pi. */
+export declare function recordAuthorizationCompleted(args: {
+    conversationId: string;
+    kind: AuthorizationKind;
+    provider: string;
+    actorId: string;
+    authorizationId: string;
+}): Promise<void>;
+/** Record a host-observed parent tool start without adding it to Pi replay. */
+export declare function recordToolExecutionStarted(args: {
+    conversationId: string;
+    args?: unknown;
+    createdAtMs?: number;
+    toolCallId: string;
+    toolName: string;
+}): Promise<void>;
+export {};

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

@@ -0,0 +1,36 @@
+import type { JuniorSqlDatabase } from "@/db/db";
+/** Content retention windows keyed by resolved conversation visibility. */
+export declare const CONTENT_RETENTION_MS: {
+    readonly public: number;
+    readonly private: number;
+};
+/** Aggregate outcome of one bounded retention purge batch. */
+export interface RetentionPurgeResult {
+    /** Root conversations examined and attempted this run. */
+    scanned: number;
+    /** Root trees successfully purged. */
+    purged: number;
+    /** Root trees whose purge failed and were skipped. */
+    failed: number;
+    /** Total conversation rows (roots plus descendants) stamped by the purge. */
+    conversations: number;
+}
+/**
+ * Run one bounded retention purge batch: delete expired root conversation trees
+ * oldest-activity-first. Each tree is purged transactionally in isolation, so a
+ * single failing tree is logged and skipped without aborting the batch, and the
+ * remainder of an over-limit backlog is left for the next run.
+ */
+export declare function runRetentionPurge(executor: JuniorSqlDatabase, args: {
+    nowMs: number;
+    limit?: number;
+}): Promise<RetentionPurgeResult>;
+/**
+ * Erase one conversation's content and descendants immediately, regardless of
+ * age, applying the same visibility-based metadata scrubbing as the purge job.
+ * The scrub decision uses the root's resolved visibility so erasing a child
+ * still fails closed to private for a private root.
+ */
+export declare function purgeConversation(executor: JuniorSqlDatabase, conversationId: string, opts?: {
+    nowMs?: number;
+}): Promise<void>;

package/dist/chat/conversations/sql/conversation-row.d.ts

@@ -0,0 +1,14 @@
+import type { JuniorSqlDatabase } from "@/db/db";
+/**
+ * Establish the conversation metadata row on first contact for content writes
+ * (agent steps, visible transcript) that can land before activity recording has
+ * created the row, and whose tables FK to it.
+ *
+ * First contact creates the row; every later content write advances the
+ * activity clock so retention mirrors append-refresh semantics (each content
+ * append refreshes the retention window). The timestamp is content-intrinsic
+ * (the first item's `createdAtMs`), and `greatest(...)` guarantees a backfilled
+ * or imported historical write — which carries an old timestamp — can never
+ * regress `last_activity_at`.
+ */
+export declare function ensureConversationRow(executor: JuniorSqlDatabase, conversationId: string, atMs: number): Promise<void>;

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

@@ -0,0 +1,4 @@
+import type { JuniorSqlDatabase } from "@/db/db";
+import { type AgentStepStore } from "../history";
+/** Create a SQL-backed agent step store. */
+export declare function createSqlAgentStepStore(executor: JuniorSqlDatabase): AgentStepStore;

package/dist/chat/conversations/sql/legacy-history-import.d.ts

@@ -0,0 +1,55 @@
+import type { JuniorSqlDatabase } from "@/db/db";
+import type { PiMessage } from "@/chat/pi/messages";
+import type { NewConversationMessage } from "../messages";
+import { type SessionLogEntry } from "@/chat/state/session-log";
+import { type AgentStepEntry } from "../history";
+/** A converted legacy step with its explicit order and epoch pinned. */
+export interface ImportedStep {
+    seq: number;
+    contextEpoch: number;
+    entry: AgentStepEntry;
+    createdAtMs: number;
+}
+/** Result of converting one conversation's legacy log. */
+export interface ConvertedLegacyLog {
+    steps: ImportedStep[];
+    /** Deterministic advisor child conversation id, when a subagent was recorded. */
+    advisorChildConversationId?: string;
+}
+/**
+ * Convert a legacy session log into ordered step rows with explicit epochs.
+ *
+ * `fallbackCreatedAtMs` supplies `created_at` for rows without an intrinsic
+ * timestamp (epoch markers, provider facts, timestamp-less messages); a real
+ * conversation-derived value is always passed so no import-time `now` is used.
+ */
+export declare function convertLegacySessionLog(args: {
+    conversationId: string;
+    entries: SessionLogEntry[];
+    fallbackCreatedAtMs: number;
+}): ConvertedLegacyLog;
+/** Convert an advisor session blob into epoch-0 child pi_message rows. */
+export declare function convertAdvisorMessages(messages: PiMessage[], fallbackCreatedAtMs: number): ImportedStep[];
+/** One conversation's converted history plus optional advisor child history. */
+export interface LegacyImportWrite {
+    conversationId: string;
+    fallbackCreatedAtMs: number;
+    lastActivityAtMs: number;
+    messages?: Array<NewConversationMessage & {
+        repliedAtMs?: number;
+    }>;
+    steps: ImportedStep[];
+    child?: {
+        conversationId: string;
+        steps: ImportedStep[];
+    };
+}
+/**
+ * Write a converted legacy history for one conversation, all-or-nothing.
+ *
+ * Serialized by a per-conversation advisory lock and skipped when step rows
+ * already exist, so a re-run (bulk or lazy) never double-imports. Parent and
+ * advisor-child rows land in one transaction; explicit `seq`/`context_epoch`
+ * are what make this need a dedicated writer rather than the narrow port.
+ */
+export declare function writeLegacyImport(executor: JuniorSqlDatabase, args: LegacyImportWrite): Promise<boolean>;

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

@@ -0,0 +1,4 @@
+import type { JuniorSqlDatabase } from "@/db/db";
+import type { ConversationMessageStore } from "../messages";
+/** Create a SQL-backed conversation message store. */
+export declare function createSqlConversationMessageStore(executor: JuniorSqlDatabase): ConversationMessageStore;

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

@@ -1,11 +1,22 @@
-import { schema } from "./schema";
-import type { JuniorSqlMigrationExecutor } from "@/chat/sql/db";
+import type { JuniorSqlMigrationExecutor } from "@/db/db";
+import { juniorSqlSchema as schema } from "@/db/schema";
 export interface Migration {
     checksum: string;
     id: string;
     statements: readonly string[];
 }
-export declare const migrations: readonly [Migration, Migration, Migration, Migration];
+/**
+ * Register a drizzle-kit-generated `.sql` file as a checksum-pinned migration.
+ *
+ * Migrations 0006 onward are authored by editing the Drizzle schema and running
+ * `pnpm --filter @sentry/junior db:generate`; each generated file becomes one
+ * line here. Statements are split on drizzle-kit's `--> statement-breakpoint`
+ * markers and applied by the custom `junior upgrade` runner (never
+ * `drizzle-kit migrate`). Migrations 0001–0005 predate kit and stay inline so
+ * their recorded checksums remain byte-stable.
+ */
+export declare function defineMigrationFromFile(id: string, fileName: string): Migration;
+export declare const migrations: readonly [Migration, Migration, Migration, Migration, Migration];
 export { schema };
 /** Apply pending SQL schema migrations for queryable conversation records. */
 export declare function migrateSchema(executor: JuniorSqlMigrationExecutor, migrationList?: readonly Migration[]): Promise<void>;

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

@@ -0,0 +1,53 @@
+import type { JuniorSqlDatabase } from "@/db/db";
+import type { JuniorDestinationVisibility } from "@/db/schema/destinations";
+/** An expired root conversation selected for purge, with its resolved visibility. */
+export interface ExpiredRoot {
+    conversationId: string;
+    visibility: JuniorDestinationVisibility | null;
+}
+/** Outcome of purging one conversation tree. */
+export interface PurgeTreeResult {
+    /** Whether this transaction still found the root eligible for purge. */
+    purged: boolean;
+    /** Root plus descendant conversation rows stamped by the purge. */
+    conversations: number;
+}
+/**
+ * Select expired root conversations for purge, oldest activity first.
+ *
+ * Roots have no parent, so visibility is read directly from the root's own
+ * destination; the private window applies to every non-`public` case. A row is
+ * skipped once it is fully purged — no content rows survive and no non-public
+ * scrub fields remain — so a bounded batch spends its budget on real work.
+ */
+export declare function selectExpiredRoots(executor: JuniorSqlDatabase, args: {
+    nowMs: number;
+    publicWindowMs: number;
+    privateWindowMs: number;
+    limit: number;
+}): Promise<ExpiredRoot[]>;
+/**
+ * Purge one conversation tree in a single transaction: delete all message and
+ * step rows for the given conversation and every descendant, stamp
+ * `transcript_purged_at`, and — for non-public content — null the raw-payload
+ * metadata (`title`, `channel_name`, legacy actor JSON) so purged private
+ * conversations keep only safe metadata. The metadata rows themselves survive.
+ */
+export declare function purgeConversationTree(executor: JuniorSqlDatabase, args: {
+    rootConversationId: string;
+    scrubMetadata?: boolean;
+    nowMs: number;
+    retention?: {
+        privateWindowMs: number;
+        publicWindowMs: number;
+    };
+}): Promise<PurgeTreeResult>;
+/**
+ * Walk `parent_conversation_id` to the root and return the root's destination
+ * visibility. Retention resolves visibility at purge time rather than storing an
+ * expiry, so a public↔private flip takes effect on the next pass.
+ */
+export declare function resolveRootVisibility(executor: JuniorSqlDatabase, conversationId: string): Promise<{
+    rootConversationId: string;
+    visibility: JuniorDestinationVisibility | null;
+}>;

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

@@ -1,7 +1,7 @@
 import type { Destination } from "@sentry/junior-plugin-api";
 import type { ConversationPrivacy } from "@/chat/conversation-privacy";
-import { type StoredSlackActor } from "@/chat/actor";
-import type { JuniorSqlDatabase, JuniorSqlMigrationExecutor } from "@/chat/sql/db";
+import type { StoredSlackActor } from "@/chat/actor";
+import type { JuniorSqlDatabase, JuniorSqlMigrationExecutor } from "@/db/db";
 import type { Conversation, ConversationExecution, ConversationSource, ConversationStore } from "../store";
 export declare class SqlStore implements ConversationStore {
     private readonly executor;
@@ -37,6 +37,11 @@ export declare class SqlStore implements ConversationStore {
         updatedAtMs: number;
         visibility?: ConversationPrivacy;
     }): Promise<void>;
+    ensureChildConversation(args: {
+        conversationId: string;
+        parentConversationId: string;
+        nowMs?: number;
+    }): Promise<void>;
     /** Copy one conversation record into SQL during backfill. */
     backfillConversation(sourceConversation: Conversation): Promise<void>;
     listByActivity(args?: {

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

@@ -22,6 +22,12 @@ export interface Conversation {
     source?: ConversationSource;
     title?: string;
     updatedAtMs: number;
+    /**
+     * When retention purged this conversation's content. Set means messages and
+     * steps were deleted wholesale; reporting presents the transcript as expired
+     * rather than privacy-redacted (`../../../specs/data-redaction-policy.md`).
+     */
+    transcriptPurgedAtMs?: number;
     /** Persisted destination visibility. Undefined means no destination row exists. */
     visibility?: ConversationPrivacy;
 }
@@ -48,6 +54,19 @@ export interface ConversationStore {
         /** Source-confirmed visibility from the current event's signal only. */
         visibility?: ConversationPrivacy;
     }): Promise<void>;
+    /**
+     * Establish a subagent child conversation row linked to its parent.
+     *
+     * Advisor and future subagent histories live under their own child
+     * `conversation_id` with `parent_conversation_id` set; the child carries no
+     * destination and is excluded from top-level listings. Idempotent: it links a
+     * bare row a step append may have created first without clobbering it.
+     */
+    ensureChildConversation(args: {
+        conversationId: string;
+        parentConversationId: string;
+        nowMs?: number;
+    }): Promise<void>;
     /** Store task-execution metadata for long-term conversation history. */
     recordExecution(args: {
         channelName?: string;

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

@@ -0,0 +1,11 @@
+import type { ThreadConversationState } from "@/chat/state/conversation";
+/** Hydrate the durable visible-context compaction snapshot from SQL. */
+export declare function hydrateConversationCompactions(args: {
+    conversation: ThreadConversationState;
+    conversationId: string;
+}): Promise<void>;
+/** Persist a changed visible-context compaction snapshot in SQL agent history. */
+export declare function persistConversationCompactions(args: {
+    conversation: ThreadConversationState;
+    conversationId: string;
+}): Promise<void>;