@happier-dev/stack 0.2.1-preview.1775586714.26562 → 0.2.12-preview.1

package/node_modules/@happier-dev/protocol/dist/sessionMessages/transcriptRawRecordV1.js

@@ -1,4 +1,7 @@
 import { z } from 'zod';
+import { ConnectedServiceAuthGroupIdSchema, ConnectedServiceIdSchema, ConnectedServiceProfileIdSchema, } from '../connect/connectedServiceSchemas.js';
+import { ConnectedServiceUxDiagnosticV1Schema } from '../connect/connectedServiceUxDiagnostics.js';
+import { SESSION_AGENT_TRANSITION_DIVIDER_SIDECAR_KEY, readSessionAgentTransitionDividerV1, } from '../sessionAgentTransitionDivider.js';
 import { createSessionMessageMetaSchema } from './sessionMessageMeta.js';
 const UsageDataSchema = z
     .object({
@@ -144,7 +147,6 @@ function preprocessMessageContent(data) {
     }
     return record;
 }
-const KNOWN_OUTPUT_DATA_TYPES = new Set(['system', 'result', 'summary', 'progress', 'assistant', 'user']);
 const OutputExtrasShape = {
     isSidechain: z.boolean().nullish(),
     isCompactSummary: z.boolean().nullish(),
@@ -183,28 +185,475 @@ const RawAgentOutputDataKnownSchema = z.discriminatedUnion('type', [
         toolUseResult: z.unknown().nullable().optional(),
     })),
 ]);
-const RawAgentOutputDataUnknownSchema = z
+const RawAgentOutputDataOpaqueSchema = z
     .object({ type: z.string() })
     .extend(OutputExtrasShape)
     .passthrough()
-    .refine((value) => !KNOWN_OUTPUT_DATA_TYPES.has(value.type), {
-    message: 'Unknown output type must not collide with known output types',
-})
+    // The strict branch is tried first. Malformed known rows and future output types
+    // remain available as opaque data while the shared output envelope stays validated.
     .transform((value) => ({ ...value, type: value.type }));
-const RawAgentOutputDataSchema = z.union([RawAgentOutputDataKnownSchema, RawAgentOutputDataUnknownSchema]);
+const RawAgentOutputDataSchema = z.union([RawAgentOutputDataKnownSchema, RawAgentOutputDataOpaqueSchema]);
+const AgentEventLifecycleShape = {
+    lifecycleId: z.string().trim().min(1).optional(),
+};
+const ContextCompactionPhaseSchema = z.preprocess((value) => value === 'detected' ? 'completed' : value, z.enum(['started', 'progress', 'completed', 'failed', 'cancelled']));
+const ContextCompactionSourceSchema = z.enum([
+    'provider-event',
+    'provider-status',
+    'provider-hook',
+    'transcript-inference',
+    'user-command',
+    'runtime',
+]);
+const ContextCompactionContinuationSchema = z.enum(['paused']);
+const ContextCompactionPauseReasonSchema = z.enum(['provider-idle-after-compaction']);
+const withAgentEventLifecycle = (schema) => schema.extend(AgentEventLifecycleShape).passthrough();
+const ProviderStateSharingDegradedEventSchema = withAgentEventLifecycle(z.object({
+    type: z.literal('provider-state-sharing-degraded'),
+    serviceId: ConnectedServiceIdSchema,
+    requestedStateMode: z.string().trim().min(1),
+    effectiveStateMode: z.string().trim().min(1),
+    code: z.string().trim().min(1),
+    reason: z.string().trim().min(1).optional(),
+})).transform((value) => {
+    const { entryName: _legacyEntryName, ...safeValue } = value;
+    return safeValue;
+});
+function readContextCompactionEventDataFromRawRecord(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return null;
+    const record = value;
+    if (record.role !== 'agent')
+        return null;
+    const content = record.content;
+    if (!content || typeof content !== 'object' || Array.isArray(content))
+        return null;
+    const contentRecord = content;
+    const data = contentRecord.data;
+    if (!data || typeof data !== 'object' || Array.isArray(data))
+        return null;
+    const dataRecord = data;
+    if (dataRecord.type !== 'context-compaction')
+        return null;
+    return contentRecord.type === 'event' || contentRecord.type === 'acp' ? dataRecord : null;
+}
+function addContextCompactionEventContinuationIssues(event, ctx, pathPrefix) {
+    if (event.continuation === 'paused' && event.phase !== 'completed') {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: [...pathPrefix, 'continuation'],
+            message: 'Context compaction paused continuation is only valid for completed phases',
+        });
+    }
+    if (event.pauseReason !== undefined && event.continuation !== 'paused') {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: [...pathPrefix, 'pauseReason'],
+            message: 'Context compaction pause reason requires paused continuation',
+        });
+    }
+}
+function addRawRecordContextCompactionContinuationIssues(value, ctx) {
+    const event = readContextCompactionEventDataFromRawRecord(value);
+    if (!event)
+        return;
+    addContextCompactionEventContinuationIssues(event, ctx, ['content', 'data']);
+}
+const ConnectedServiceAccountSwitchReasonSchema = z.enum([
+    'usage_limit',
+    'soft_threshold',
+    'auth_expired',
+    'account_changed',
+    'refresh_failure',
+    'manual',
+]);
+const ConnectedServiceAccountSwitchModeSchema = z.enum([
+    'hot_apply',
+    'restart_resume',
+    'spawn_next_turn',
+]);
+export const ConnectedServiceSwitchAttemptedContinuityModeV1Schema = z.enum([
+    'hot_apply',
+    'restart',
+    'metadata_only',
+    'credential_refresh',
+]);
+export const ConnectedServiceSwitchAttemptOutcomeV1Schema = z.enum([
+    'succeeded',
+    'failed',
+    'observed',
+    'scheduled_retry',
+    'terminal',
+]);
+export const ConnectedServiceSwitchAttemptOutcomeActionV1Schema = z.enum([
+    'hot_applied',
+    'restarted',
+    'metadata_updated',
+    'credential_refreshed',
+    'none',
+]);
+export const ConnectedServiceSwitchAttemptSessionAdoptionV1Schema = z.enum([
+    'applied',
+    'failed',
+    'observed_only',
+    'not_applicable',
+]);
+const ConnectedServiceSwitchAttemptVerificationByServiceIdV1Schema = z.partialRecord(ConnectedServiceIdSchema, z.object({
+    status: z.enum(['verified', 'weakly_verified']),
+    providerAccountId: z.string().trim().min(1).nullable().optional(),
+    activeAccountId: z.string().trim().min(1).nullable().optional(),
+    sharedAuthSurfaceId: z.string().trim().min(1).nullable().optional(),
+    proofStrength: z.enum(['exact', 'weak', 'diagnostic']).optional(),
+    source: z.string().trim().min(1).optional(),
+    reason: z.string().trim().min(1).optional(),
+}));
+const ConnectedServiceAccountSwitchDeferralPolicySchema = z.enum([
+    'defer_until_turn_boundary',
+    'defer_until_idle',
+]);
+const ConnectedServiceAccountSwitchDeferralCompletionReasonSchema = z.enum([
+    'completed_at_boundary',
+    'aborted_after_timeout',
+    'switch_cancelled',
+    'session_terminated',
+    'daemon_shutdown',
+]);
+export const ConnectedServiceRuntimeAuthRecoveryTranscriptStatusV1Schema = z.enum([
+    'retry_scheduled',
+    'dead_lettered',
+    'recovered',
+    'cancelled',
+]);
+const CONNECTED_SERVICE_SWITCH_ATTEMPT_V2_FIELDS = [
+    'attemptedContinuityMode',
+    'outcomeAction',
+    'diagnostic',
+    'groupGeneration',
+    'sessionAdoption',
+    'sessionAdoptedGeneration',
+];
+function addConnectedServiceAccountSwitchAttemptEventIssues(event, ctx) {
+    if (event.type !== 'connected-service-account-switch-attempt')
+        return;
+    const hasV2SemanticField = CONNECTED_SERVICE_SWITCH_ATTEMPT_V2_FIELDS.some((field) => event[field] !== undefined);
+    if (hasV2SemanticField && event.outcome === undefined) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: ['outcome'],
+            message: 'new connected-service switch attempt semantics require an explicit outcome',
+        });
+    }
+    if (event.ok === false && event.outcome === 'succeeded') {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: ['outcome'],
+            message: 'failed switch attempts must not use a succeeded outcome',
+        });
+    }
+    if (event.ok === true && (event.outcome === 'failed' || event.outcome === 'terminal')) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: ['outcome'],
+            message: 'successful switch attempts must not use a failed or terminal outcome',
+        });
+    }
+    if ((event.outcome === 'failed' || event.outcome === 'terminal')
+        && event.outcomeAction !== undefined
+        && event.outcomeAction !== 'none') {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: ['outcomeAction'],
+            message: 'failed or terminal switch attempt outcomes must not claim a successful outcome action',
+        });
+    }
+    if (event.outcomeAction !== undefined && event.outcome === undefined) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: ['outcome'],
+            message: 'switch attempt outcomeAction requires an explicit outcome',
+        });
+    }
+    if (event.sessionAdoption !== undefined && event.groupGeneration === undefined) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: ['groupGeneration'],
+            message: 'session adoption projection requires the observed group generation',
+        });
+    }
+    if (event.sessionAdoptedGeneration !== undefined && event.groupGeneration === undefined) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: ['groupGeneration'],
+            message: 'session adopted generation requires the observed group generation',
+        });
+    }
+    if ((event.outcome === 'failed' || event.outcome === 'terminal')
+        && event.sessionAdoption === 'applied') {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: ['sessionAdoption'],
+            message: 'failed or terminal switch attempts must not claim per-session adoption',
+        });
+    }
+    if (event.sessionAdoption === 'applied') {
+        if (event.sessionAdoptedGeneration === undefined) {
+            ctx.addIssue({
+                code: z.ZodIssueCode.custom,
+                path: ['sessionAdoptedGeneration'],
+                message: 'applied session adoption requires a per-session adopted generation',
+            });
+        }
+        if (typeof event.groupGeneration === 'number'
+            && typeof event.sessionAdoptedGeneration === 'number'
+            && event.groupGeneration !== event.sessionAdoptedGeneration) {
+            ctx.addIssue({
+                code: z.ZodIssueCode.custom,
+                path: ['sessionAdoptedGeneration'],
+                message: 'applied session adoption must target the observed group generation',
+            });
+        }
+    }
+    else if (event.sessionAdoptedGeneration !== undefined) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: ['sessionAdoptedGeneration'],
+            message: 'session adopted generation is valid only when session adoption is applied',
+        });
+    }
+}
+function addConnectedServiceRuntimeAuthRecoveryEventIssues(event, ctx) {
+    if (event.type !== 'connected-service-runtime-auth-recovery')
+        return;
+    const diagnostic = event.diagnostic;
+    if ((event.status === 'retry_scheduled' || event.status === 'dead_lettered') && diagnostic === undefined) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: ['diagnostic'],
+            message: 'scheduled and dead-lettered runtime-auth recovery events require a diagnostic',
+        });
+        return;
+    }
+    if (!diagnostic || typeof diagnostic !== 'object' || Array.isArray(diagnostic))
+        return;
+    const diagnosticRecord = diagnostic;
+    if (diagnosticRecord.source !== 'runtime_auth_recovery') {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: ['diagnostic', 'source'],
+            message: 'runtime-auth recovery event diagnostics must use runtime_auth_recovery source',
+        });
+    }
+    if (diagnosticRecord.failurePhase !== 'runtime_auth_recovery') {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: ['diagnostic', 'failurePhase'],
+            message: 'runtime-auth recovery event diagnostics must use runtime_auth_recovery failure phase',
+        });
+    }
+}
+// The five public runtime-config-outcome statuses are frozen. Queued/scheduled/skipped
+// state is carried by the optional `timing` field below, never by new status enum values,
+// because older clients reject unknown enum values for a known field.
+export const RuntimeConfigOutcomeStatusV1Schema = z.enum([
+    'applied',
+    'requires_restart',
+    'requires_interactive_control',
+    'unsupported',
+    'failed',
+]);
+// Optional timing detail for a runtime-config outcome. This is NOT a status; it explains
+// when the (already statused) change takes effect relative to the active TUI/turn window.
+export const RuntimeConfigOutcomeTimingV1Schema = z.enum([
+    'current_window',
+    'queued_until_safe_window',
+    'scheduled_for_next_prompt',
+    'next_idle',
+    'before_next_prompt',
+    'skipped_already_effective',
+    'not_applicable',
+]);
+export const RuntimeConfigOutcomeChangeKeyV1Schema = z.enum([
+    'model',
+    'fallbackModel',
+    'permissionMode',
+    'reasoningEffort',
+    'maxThinkingTokens',
+    'launchOption',
+    'sessionMode',
+]);
+const RuntimeConfigOutcomeScalarV1Schema = z.union([
+    z.string().trim().min(1).max(512),
+    z.number().finite(),
+    z.boolean(),
+    z.null(),
+]);
+const RuntimeConfigOutcomeChangeV1Schema = z
+    .object({
+    key: RuntimeConfigOutcomeChangeKeyV1Schema,
+    requested: RuntimeConfigOutcomeScalarV1Schema.optional(),
+    previous: RuntimeConfigOutcomeScalarV1Schema.optional(),
+    effective: RuntimeConfigOutcomeScalarV1Schema.optional(),
+    reason: z.string().trim().min(1).max(512).optional(),
+})
+    .strict();
+const TerminalComposerDraftBlockedReasonV1Schema = z.enum([
+    'idle_draft_guard',
+    'in_flight_steer',
+]);
 const AgentEventSchema = z.discriminatedUnion('type', [
-    z.object({ type: z.literal('switch'), mode: z.enum(['local', 'remote']) }).passthrough(),
-    z.object({ type: z.literal('message'), message: z.string() }).passthrough(),
-    z.object({ type: z.literal('limit-reached'), endsAt: z.number() }).passthrough(),
-    z
-        .object({
+    withAgentEventLifecycle(z.object({ type: z.literal('switch'), mode: z.enum(['local', 'remote']) })),
+    withAgentEventLifecycle(z.object({
+        type: z.literal('message'),
+        message: z.string(),
+        /**
+         * Same-Session cross-Agent transition divider. This is a strict nested
+         * sidecar on the EXISTING passthrough `message` arm, never a new
+         * `AgentEventSchema` variant: this union is closed at the discriminator,
+         * so a new variant would be dropped by every released reader.
+         * `withAgentEventLifecycle` ends in `.passthrough()`, so an old reader
+         * parses this row as an ordinary informational message and keeps the
+         * sidecar untouched.
+         *
+         * Declared as `unknown` ON PURPOSE. A strict nested schema here would
+         * invalidate the whole discriminated-union member on a malformed or
+         * future-version sidecar, and this arm accepted arbitrary extra keys
+         * before the divider existed — so one write at this key name would erase
+         * an otherwise valid transcript row for every reader. Strictness lives at
+         * the two places that can act on it: writers parse
+         * {@link SessionAgentTransitionDividerV1Schema} before sealing, and the
+         * single canonical reader
+         * {@link readSessionAgentTransitionDividerV1} strict-parses and returns
+         * `null` for anything else — so a malformed sidecar is never treated as a
+         * divider, never silenced, and never a departure boundary.
+         */
+        [SESSION_AGENT_TRANSITION_DIVIDER_SIDECAR_KEY]: z.unknown().optional(),
+    })),
+    withAgentEventLifecycle(z.object({
+        type: z.literal('terminal-composer-draft-blocked'),
+        reason: TerminalComposerDraftBlockedReasonV1Schema,
+        stateAtMs: z.number().int().nonnegative().optional(),
+        message: z.string().trim().min(1).max(2000).optional(),
+    })),
+    withAgentEventLifecycle(z.object({
+        type: z.literal('runtime-config-outcome'),
+        provider: z.string().trim().min(1).max(128).optional(),
+        runtime: z.string().trim().min(1).max(128),
+        status: RuntimeConfigOutcomeStatusV1Schema,
+        timing: RuntimeConfigOutcomeTimingV1Schema.optional(),
+        reason: z.string().trim().min(1).max(256).optional(),
+        message: z.string().trim().min(1).max(2_000),
+        changes: z.array(RuntimeConfigOutcomeChangeV1Schema).max(20).optional(),
+    })),
+    withAgentEventLifecycle(z.object({
+        type: z.literal('context-compaction'),
+        phase: ContextCompactionPhaseSchema,
+        provider: z.string().trim().min(1).optional(),
+        backendId: z.string().trim().min(1).optional(),
+        agentId: z.string().trim().min(1).optional(),
+        trigger: z.enum(['manual', 'auto', 'threshold', 'overflow', 'unknown']).optional(),
+        source: ContextCompactionSourceSchema.optional(),
+        providerEventId: z.string().optional(),
+        providerSessionId: z.string().optional(),
+        turnId: z.string().optional(),
+        tokenCountBefore: z.number().optional(),
+        tokenCountAfter: z.number().optional(),
+        tokenCountSource: z.string().optional(),
+        retryAttempt: z.number().int().nonnegative().optional(),
+        errorCode: z.string().optional(),
+        sanitizedErrorPreview: z.string().optional(),
+        continuation: ContextCompactionContinuationSchema.optional(),
+        pauseReason: ContextCompactionPauseReasonSchema.optional(),
+    })),
+    withAgentEventLifecycle(z.object({ type: z.literal('limit-reached'), endsAt: z.number() })),
+    withAgentEventLifecycle(z.object({
+        type: z.literal('connected-service-account-switch'),
+        serviceId: ConnectedServiceIdSchema,
+        groupId: ConnectedServiceAuthGroupIdSchema.nullable(),
+        groupLabel: z.string().trim().min(1).nullable().optional(),
+        fromProfileId: ConnectedServiceProfileIdSchema.nullable(),
+        toProfileId: ConnectedServiceProfileIdSchema.nullable(),
+        fromProfileLabel: z.string().trim().min(1).nullable().optional(),
+        toProfileLabel: z.string().trim().min(1).nullable().optional(),
+        reason: ConnectedServiceAccountSwitchReasonSchema,
+        mode: ConnectedServiceAccountSwitchModeSchema,
+        resetAtMs: z.number().int().nonnegative().optional(),
+        effectiveRemainingPct: z.number().finite().min(0).max(100).optional(),
+    })),
+    withAgentEventLifecycle(z.object({
+        type: z.literal('connected-service-account-switch-deferral'),
+        policy: ConnectedServiceAccountSwitchDeferralPolicySchema,
+        awaitingBoundary: z.boolean(),
+        timeoutMs: z.number().int().nonnegative(),
+    })),
+    withAgentEventLifecycle(z.object({
+        type: z.literal('connected-service-account-switch-deferral-completed'),
+        policy: ConnectedServiceAccountSwitchDeferralPolicySchema,
+        reason: ConnectedServiceAccountSwitchDeferralCompletionReasonSchema,
+    })),
+    withAgentEventLifecycle(z.object({
+        type: z.literal('connected-service-account-switch-deferral-superseded'),
+        policy: ConnectedServiceAccountSwitchDeferralPolicySchema.optional(),
+    })),
+    withAgentEventLifecycle(z.object({
+        type: z.literal('connected-service-account-switch-attempt'),
+        ok: z.boolean(),
+        action: z.enum(['restart_requested', 'hot_applied', 'metadata_updated']),
+        attemptedContinuityMode: ConnectedServiceSwitchAttemptedContinuityModeV1Schema.optional(),
+        outcome: ConnectedServiceSwitchAttemptOutcomeV1Schema.optional(),
+        outcomeAction: ConnectedServiceSwitchAttemptOutcomeActionV1Schema.optional(),
+        errorCode: z.string().trim().min(1).nullable().optional(),
+        diagnostic: ConnectedServiceUxDiagnosticV1Schema.optional(),
+        groupGeneration: z.number().int().nonnegative().optional(),
+        sessionAdoption: ConnectedServiceSwitchAttemptSessionAdoptionV1Schema.optional(),
+        sessionAdoptedGeneration: z.number().int().nonnegative().optional(),
+        partialState: z
+            .enum(['metadata_may_reference_new_binding', 'runtime_auth_applied', 'runtime_auth_partially_applied'])
+            .nullable()
+            .optional(),
+        verificationByServiceId: ConnectedServiceSwitchAttemptVerificationByServiceIdV1Schema.optional(),
+    })),
+    withAgentEventLifecycle(z.object({
+        type: z.literal('connected-service-runtime-auth-recovery'),
+        status: ConnectedServiceRuntimeAuthRecoveryTranscriptStatusV1Schema,
+        serviceId: ConnectedServiceIdSchema,
+        profileId: ConnectedServiceProfileIdSchema.optional(),
+        groupId: ConnectedServiceAuthGroupIdSchema.optional(),
+        attempt: z.number().int().positive().optional(),
+        nextRetryAtMs: z.number().int().nonnegative().nullable().optional(),
+        terminal: z.boolean().optional(),
+        diagnostic: ConnectedServiceUxDiagnosticV1Schema.optional(),
+        reason: z.string().trim().min(1).optional(),
+    })),
+    ProviderStateSharingDegradedEventSchema,
+    withAgentEventLifecycle(z.object({
+        type: z.literal('provider-quota-wait'),
+        serviceId: ConnectedServiceIdSchema,
+        profileId: ConnectedServiceProfileIdSchema.optional(),
+        groupId: ConnectedServiceAuthGroupIdSchema.optional(),
+        resetAtMs: z.number().int().nonnegative(),
+        reason: z.string().trim().min(1),
+    })),
+    withAgentEventLifecycle(z.object({
+        type: z.literal('provider-quota-recovered'),
+        serviceId: ConnectedServiceIdSchema,
+        profileId: ConnectedServiceProfileIdSchema.optional(),
+        groupId: ConnectedServiceAuthGroupIdSchema.optional(),
+        reason: z.string().trim().min(1).optional(),
+    })),
+    withAgentEventLifecycle(z.object({
         type: z.literal('task-lifecycle'),
-        event: z.enum(['task_started', 'task_complete', 'turn_aborted']),
+        event: z.enum(['task_started', 'task_complete', 'turn_failed', 'turn_cancelled', 'turn_aborted']),
         id: z.string().nullable().optional(),
-    })
-        .passthrough(),
-    z.object({ type: z.literal('ready') }).passthrough(),
-]);
+    })),
+    withAgentEventLifecycle(z.object({ type: z.literal('ready') })),
+]).superRefine((event, ctx) => {
+    if (event.type === 'context-compaction') {
+        addContextCompactionEventContinuationIssues(event, ctx, []);
+    }
+    const eventRecord = event;
+    addConnectedServiceAccountSwitchAttemptEventIssues(eventRecord, ctx);
+    addConnectedServiceRuntimeAuthRecoveryEventIssues(eventRecord, ctx);
+});
 const RawAgentRecordSchema = z
     .discriminatedUnion('type', [
     z.object({
@@ -220,6 +669,11 @@ const RawAgentRecordSchema = z
             z.object({ type: z.literal('reasoning'), message: z.string(), sidechainId: z.string().optional() }),
             z.object({ type: z.literal('message'), message: z.string(), sidechainId: z.string().optional() }),
             z.object({ type: z.literal('token_count'), sidechainId: z.string().optional() }).passthrough(),
+            z.object({ type: z.literal('task_started'), id: z.string().optional(), sidechainId: z.string().optional() }).passthrough(),
+            z.object({ type: z.literal('task_complete'), id: z.string().optional(), sidechainId: z.string().optional() }).passthrough(),
+            z.object({ type: z.literal('turn_failed'), id: z.string().optional(), sidechainId: z.string().optional() }).passthrough(),
+            z.object({ type: z.literal('turn_cancelled'), id: z.string().optional(), sidechainId: z.string().optional() }).passthrough(),
+            z.object({ type: z.literal('turn_aborted'), id: z.string().optional(), sidechainId: z.string().optional() }).passthrough(),
             z
                 .object({
                 type: z.literal('tool-call'),
@@ -239,6 +693,15 @@ const RawAgentRecordSchema = z
                 sidechainId: z.string().optional(),
             })
                 .passthrough(),
+            z
+                .object({
+                type: z.literal('tool-result'),
+                callId: z.string(),
+                output: z.unknown(),
+                id: z.string(),
+                sidechainId: z.string().optional(),
+            })
+                .passthrough(),
         ]),
     })
         .passthrough(),
@@ -258,9 +721,12 @@ const RawAgentRecordSchema = z
                 'terminal-output',
                 'task_started',
                 'task_complete',
+                'turn_failed',
+                'turn_cancelled',
                 'turn_aborted',
                 'permission-request',
                 'token_count',
+                'context-compaction',
             ]);
             const known = z.discriminatedUnion('type', [
                 z.object({ type: z.literal('reasoning'), message: z.string(), sidechainId: z.string().optional() }).passthrough(),
@@ -317,6 +783,8 @@ const RawAgentRecordSchema = z
                     .passthrough(),
                 z.object({ type: z.literal('task_started'), id: z.string(), sidechainId: z.string().optional() }).passthrough(),
                 z.object({ type: z.literal('task_complete'), id: z.string(), sidechainId: z.string().optional() }).passthrough(),
+                z.object({ type: z.literal('turn_failed'), id: z.string(), sidechainId: z.string().optional() }).passthrough(),
+                z.object({ type: z.literal('turn_cancelled'), id: z.string(), sidechainId: z.string().optional() }).passthrough(),
                 z.object({ type: z.literal('turn_aborted'), id: z.string(), sidechainId: z.string().optional() }).passthrough(),
                 z
                     .object({
@@ -329,6 +797,30 @@ const RawAgentRecordSchema = z
                 })
                     .passthrough(),
                 z.object({ type: z.literal('token_count'), sidechainId: z.string().optional() }).passthrough(),
+                z
+                    .object({
+                    type: z.literal('context-compaction'),
+                    phase: ContextCompactionPhaseSchema,
+                    lifecycleId: z.string().trim().min(1).optional(),
+                    provider: z.string().trim().min(1).optional(),
+                    backendId: z.string().trim().min(1).optional(),
+                    agentId: z.string().trim().min(1).optional(),
+                    trigger: z.enum(['manual', 'auto', 'threshold', 'overflow', 'unknown']).optional(),
+                    source: ContextCompactionSourceSchema.optional(),
+                    providerEventId: z.string().optional(),
+                    providerSessionId: z.string().optional(),
+                    turnId: z.string().optional(),
+                    tokenCountBefore: z.number().optional(),
+                    tokenCountAfter: z.number().optional(),
+                    tokenCountSource: z.string().optional(),
+                    retryAttempt: z.number().int().nonnegative().optional(),
+                    errorCode: z.string().optional(),
+                    sanitizedErrorPreview: z.string().optional(),
+                    continuation: ContextCompactionContinuationSchema.optional(),
+                    pauseReason: ContextCompactionPauseReasonSchema.optional(),
+                    sidechainId: z.string().optional(),
+                })
+                    .passthrough(),
             ]);
             const unknown = z
                 .object({ type: z.string() })
@@ -363,11 +855,123 @@ export function createTranscriptRawRecordV1Schema(zod, options) {
             meta: metaSchema.optional(),
         })
             .passthrough(),
-    ]));
+    ])).superRefine(addRawRecordContextCompactionContinuationIssues);
 }
 export const TranscriptRawRecordV1Schema = createTranscriptRawRecordV1Schema(z);
 export const TranscriptRawUsageDataV1Schema = UsageDataSchema;
 export const TranscriptRawAgentEventV1Schema = AgentEventSchema;
+export const SessionMessageAttentionImpactSchema = z.object({
+    affectsUnread: z.boolean(),
+    affectsMeaningfulActivity: z.boolean(),
+}).strict();
+export const SESSION_MESSAGE_USER_ATTENTION_IMPACT = Object.freeze({
+    affectsUnread: true,
+    affectsMeaningfulActivity: true,
+});
+export const SESSION_MESSAGE_NO_USER_ATTENTION_IMPACT = Object.freeze({
+    affectsUnread: false,
+    affectsMeaningfulActivity: false,
+});
+const AGENT_EVENT_TYPES_WITHOUT_USER_ATTENTION = new Set([
+    'connected-service-account-switch',
+    'connected-service-account-switch-deferral',
+    'connected-service-account-switch-deferral-completed',
+    'connected-service-account-switch-deferral-superseded',
+    'connected-service-account-switch-attempt',
+    'provider-state-sharing-degraded',
+    'provider-quota-wait',
+    'provider-quota-recovered',
+]);
+const RUNTIME_AUTH_RECOVERY_STATUSES_WITHOUT_USER_ATTENTION = new Set([
+    'retry_scheduled',
+    'recovered',
+    'cancelled',
+]);
+function readAgentEventType(value) {
+    return typeof value?.type === 'string'
+        ? value.type
+        : null;
+}
+function sanitizeAgentEventLocalIdPart(value) {
+    const normalized = String(value ?? '').trim().replace(/[^A-Za-z0-9_-]+/g, '_').replace(/^_+|_+$/g, '');
+    return normalized.length > 0 ? normalized : null;
+}
+export function buildAgentEventLocalId(type, parts) {
+    const normalizedType = sanitizeAgentEventLocalIdPart(type);
+    if (!normalizedType) {
+        throw new Error('Agent event local id type must not be empty');
+    }
+    const normalizedParts = parts.map(sanitizeAgentEventLocalIdPart).filter((part) => part !== null);
+    return [normalizedType, ...normalizedParts].join(':');
+}
+function readAgentEventLocalIdType(value) {
+    if (typeof value !== 'string')
+        return null;
+    const candidateType = value.trim().split(':', 1)[0];
+    if (candidateType === 'connected-service-runtime-auth-recovery') {
+        return candidateType;
+    }
+    return AGENT_EVENT_TYPES_WITHOUT_USER_ATTENTION.has(candidateType)
+        ? candidateType
+        : null;
+}
+function readRuntimeAuthRecoveryStatusFromLocalId(localId) {
+    const parts = localId.trim().split(':');
+    const currentShapeStatus = ConnectedServiceRuntimeAuthRecoveryTranscriptStatusV1Schema.safeParse(parts[4]);
+    if (currentShapeStatus.success)
+        return currentShapeStatus.data;
+    for (let index = 1; index < parts.length - 1; index++) {
+        if (parts[index] !== 'status')
+            continue;
+        const labelledStatus = ConnectedServiceRuntimeAuthRecoveryTranscriptStatusV1Schema.safeParse(parts[index + 1]);
+        if (labelledStatus.success)
+            return labelledStatus.data;
+    }
+    if (parts.length <= 4) {
+        const compactShapeStatus = ConnectedServiceRuntimeAuthRecoveryTranscriptStatusV1Schema.safeParse(parts[parts.length - 1]);
+        if (compactShapeStatus.success)
+            return compactShapeStatus.data;
+    }
+    return null;
+}
+export function agentEventAttentionImpact(event, localId) {
+    const type = readAgentEventType(event);
+    // The same-Session transition divider is a boundary marker, not news for the
+    // user. It rides the ordinary passthrough `message` arm, so the decision is
+    // conditioned on the canonical reader's complete identity — the strict
+    // sidecar AND its reserved outer localId — and never on event type. A bare
+    // `message` must remain attention-bearing, and a sidecar on an ordinary row
+    // is not a trusted divider.
+    //
+    // This is the single attention decision. `attentionImpact` is not a persisted
+    // column, so every re-read re-derives from stored content and both the server
+    // resolver and the client resolvers reach this function — teaching them
+    // separately would create a third decision-maker.
+    if (readSessionAgentTransitionDividerV1({ localId, event }) !== null) {
+        return SESSION_MESSAGE_NO_USER_ATTENTION_IMPACT;
+    }
+    if (type === 'connected-service-runtime-auth-recovery') {
+        const parsedStatus = ConnectedServiceRuntimeAuthRecoveryTranscriptStatusV1Schema.safeParse(event?.status);
+        return parsedStatus.success && RUNTIME_AUTH_RECOVERY_STATUSES_WITHOUT_USER_ATTENTION.has(parsedStatus.data)
+            ? SESSION_MESSAGE_NO_USER_ATTENTION_IMPACT
+            : SESSION_MESSAGE_USER_ATTENTION_IMPACT;
+    }
+    return type !== null && AGENT_EVENT_TYPES_WITHOUT_USER_ATTENTION.has(type)
+        ? SESSION_MESSAGE_NO_USER_ATTENTION_IMPACT
+        : SESSION_MESSAGE_USER_ATTENTION_IMPACT;
+}
+export function agentEventLocalIdAttentionImpact(localId) {
+    const type = readAgentEventLocalIdType(localId);
+    if (type === null || typeof localId !== 'string')
+        return null;
+    if (type === 'connected-service-runtime-auth-recovery') {
+        return agentEventAttentionImpact({
+            type,
+            status: readRuntimeAuthRecoveryStatusFromLocalId(localId),
+        }, localId);
+    }
+    return agentEventAttentionImpact({ type }, localId);
+}
 export const TranscriptRawAgentContentV1Schema = RawAgentContentSchema;
 export const TranscriptRawAgentRecordV1Schema = RawAgentRecordSchema;
 //# sourceMappingURL=transcriptRawRecordV1.js.map