fix(protocol): add question and approval lifecycle events to the schema

The question/approval services published seven event types through unchecked casts that were never registered in agentEventSchema, so journals containing them failed validation on read (error 50001) and bricked session loading. Register the schemas, drop the casts, and cover the real journal shapes with regression tests.

Author: elkaix

packages/protocol/src/__tests__/ws-control.test.ts

@@ -750,4 +750,82 @@ describe('ws-control — operation registry', () => {
       }).success,
     ).toBe(true);
   });
+
+  it('accepts journaled question and approval events', () => {
+    const sessionId = 'session_test';
+    const epoch = 'epoch_test';
+    const message = (
+      type: string,
+      seq: number,
+      fields: Record<string, unknown>,
+    ) => ({
+      type,
+      seq,
+      epoch,
+      session_id: sessionId,
+      timestamp: TS,
+      payload: {
+        type,
+        agentId: 'main',
+        sessionId,
+        ...fields,
+      },
+    });
+    const approvalRequest = {
+      approval_id: 'approval_test',
+      session_id: sessionId,
+      turn_id: 1,
+      tool_call_id: 'tool_call_test',
+      tool_name: 'shell.run',
+      action: 'Run a command',
+      tool_input_display: { kind: 'generic', summary: 'test' },
+      created_at: TS,
+      expires_at: '2026-06-04T10:31:00.000Z',
+    };
+
+    const events = [
+      message('event.question.requested', 1, {
+        question_id: 'question_test',
+        session_id: sessionId,
+        questions: [{
+          id: 'q_0',
+          question: 'Which option?',
+          options: [{ id: 'opt_0_0', label: 'A', description: 'First option' }],
+          header: 'Choice',
+          allow_other: true,
+          other_label: 'Other',
+        }],
+        created_at: TS,
+        expires_at: '2026-06-04T10:31:00.000Z',
+      }),
+      message('event.question.answered', 2, {
+        question_id: 'question_test',
+        answers: { q_0: 'opt_0_0' },
+        resolved_at: TS,
+      }),
+      message('event.question.dismissed', 3, {
+        question_id: 'question_test',
+        dismissed_at: TS,
+      }),
+      message('event.question.expired', 4, {
+        question_id: 'question_test',
+      }),
+      message('event.approval.requested', 5, approvalRequest),
+      message('event.approval.resolved', 6, {
+        approval_id: 'approval_test',
+        decision: 'approved',
+        scope: 'session',
+        feedback: 'Proceed',
+        selected_label: 'Approve',
+        resolved_at: TS,
+      }),
+      message('event.approval.expired', 7, {
+        approval_id: 'approval_test',
+      }),
+    ];
+
+    for (const event of events) {
+      expect(sessionEventMessageSchema.safeParse(event).success).toBe(true);
+    }
+  });
 });

packages/protocol/src/events.ts

@@ -6,6 +6,13 @@ import { sessionSchema, sessionStatusSchema, type Session, type SessionStatus }
 import { isoDateTimeSchema } from './time';
 import { configResponseSchema, type ConfigResponse } from './rest/config';
 import { workspaceSchema, type Workspace } from './workspace';
+import {
+  approvalRequestSchema,
+  approvalResponseSchema,
+  type ApprovalRequest,
+  type ApprovalResponse,
+} from './approval';
+import { questionRequestSchema, type QuestionRequest } from './question';
 
 export interface TokenUsage {
   readonly inputOther: number;
@@ -355,6 +362,43 @@ export interface SessionStatusChangedEvent {
   readonly current_prompt_id?: string;
 }
 
+export interface QuestionRequestedEvent extends QuestionRequest {
+  readonly type: 'event.question.requested';
+}
+
+export interface QuestionAnsweredEvent {
+  readonly type: 'event.question.answered';
+  readonly question_id: string;
+  readonly answers: unknown;
+  readonly resolved_at: string;
+}
+
+export interface QuestionDismissedEvent {
+  readonly type: 'event.question.dismissed';
+  readonly question_id: string;
+  readonly dismissed_at: string;
+}
+
+export interface QuestionExpiredEvent {
+  readonly type: 'event.question.expired';
+  readonly question_id: string;
+}
+
+export interface ApprovalRequestedEvent extends ApprovalRequest {
+  readonly type: 'event.approval.requested';
+}
+
+export interface ApprovalResolvedEvent extends ApprovalResponse {
+  readonly type: 'event.approval.resolved';
+  readonly approval_id: string;
+  readonly resolved_at: string;
+}
+
+export interface ApprovalExpiredEvent {
+  readonly type: 'event.approval.expired';
+  readonly approval_id: string;
+}
+
 export interface ConfigChangedEvent {
   readonly type: 'event.config.changed';
   readonly changedFields: string[];
@@ -693,6 +737,13 @@ export type AgentEvent =
   | WorkspaceUpdatedEvent
   | WorkspaceDeletedEvent
   | SessionStatusChangedEvent
+  | QuestionRequestedEvent
+  | QuestionAnsweredEvent
+  | QuestionDismissedEvent
+  | QuestionExpiredEvent
+  | ApprovalRequestedEvent
+  | ApprovalResolvedEvent
+  | ApprovalExpiredEvent
   | ConfigChangedEvent
   | GoalUpdatedEvent
   | SkillActivatedEvent
@@ -1082,6 +1133,43 @@ export const sessionStatusChangedEventSchema = z.object({
   current_prompt_id: z.string().min(1).optional(),
 }) satisfies z.ZodType<SessionStatusChangedEvent>;
 
+export const questionRequestedEventSchema = questionRequestSchema.extend({
+  type: z.literal('event.question.requested'),
+}) satisfies z.ZodType<QuestionRequestedEvent>;
+
+export const questionAnsweredEventSchema = z.object({
+  type: z.literal('event.question.answered'),
+  question_id: z.string().min(1),
+  answers: z.unknown().nullable(),
+  resolved_at: isoDateTimeSchema,
+}) satisfies z.ZodType<QuestionAnsweredEvent>;
+
+export const questionDismissedEventSchema = z.object({
+  type: z.literal('event.question.dismissed'),
+  question_id: z.string().min(1),
+  dismissed_at: isoDateTimeSchema,
+}) satisfies z.ZodType<QuestionDismissedEvent>;
+
+export const questionExpiredEventSchema = z.object({
+  type: z.literal('event.question.expired'),
+  question_id: z.string().min(1),
+}) satisfies z.ZodType<QuestionExpiredEvent>;
+
+export const approvalRequestedEventSchema = approvalRequestSchema.extend({
+  type: z.literal('event.approval.requested'),
+}) satisfies z.ZodType<ApprovalRequestedEvent>;
+
+export const approvalResolvedEventSchema = approvalResponseSchema.extend({
+  type: z.literal('event.approval.resolved'),
+  approval_id: z.string().min(1),
+  resolved_at: isoDateTimeSchema,
+}) satisfies z.ZodType<ApprovalResolvedEvent>;
+
+export const approvalExpiredEventSchema = z.object({
+  type: z.literal('event.approval.expired'),
+  approval_id: z.string().min(1),
+}) satisfies z.ZodType<ApprovalExpiredEvent>;
+
 export const configChangedEventSchema = z.object({
   type: z.literal('event.config.changed'),
   changedFields: z.array(z.string()),
@@ -1406,6 +1494,13 @@ export const agentEventSchema = z.discriminatedUnion('type', [
   workspaceUpdatedEventSchema,
   workspaceDeletedEventSchema,
   sessionStatusChangedEventSchema,
+  questionRequestedEventSchema,
+  questionAnsweredEventSchema,
+  questionDismissedEventSchema,
+  questionExpiredEventSchema,
+  approvalRequestedEventSchema,
+  approvalResolvedEventSchema,
+  approvalExpiredEventSchema,
   goalUpdatedEventSchema,
   skillActivatedEventSchema,
   advisorStatusEventSchema,

packages/server/src/services/approval/approvalService.ts

@@ -106,7 +106,7 @@ export class ApprovalService extends Disposable implements IApprovalService {
       sessionId: req.sessionId,
       agentId: req.agentId,
       ...protocolRequest,
-    } as unknown as Event;
+    };
 
     this.eventService.publish(event);
 
@@ -160,7 +160,7 @@ export class ApprovalService extends Disposable implements IApprovalService {
       feedback: response.feedback,
       selected_label: response.selectedLabel,
       resolved_at: resolvedAt,
-    } as unknown as Event;
+    };
     this.eventService.publish(resolvedEvent);
 
     p.resolve(response);
@@ -217,7 +217,7 @@ export class ApprovalService extends Disposable implements IApprovalService {
       sessionId: p.sessionId,
       agentId: 'main',
       approval_id: p.approvalId,
-    } as unknown as Event;
+    };
     this.eventService.publish(expiredEvent);
 
     p.reject(new ApprovalExpiredError(p.approvalId, this._timeoutMs));

packages/server/src/services/question/questionService.ts

@@ -104,7 +104,7 @@ export class QuestionService extends Disposable implements IQuestionService {
       sessionId: req.sessionId,
       agentId: req.agentId,
       ...protocolRequest,
-    } as unknown as Event;
+    };
     this.eventService.publish(event);
 
     this.logger.info(
@@ -154,7 +154,7 @@ export class QuestionService extends Disposable implements IQuestionService {
       question_id: p.questionId,
       answers: response === null ? null : (response as { answers?: unknown }).answers ?? response,
       resolved_at: resolvedAt,
-    } as unknown as Event;
+    };
     this.eventService.publish(answeredEvent);
 
     p.resolve(response);
@@ -174,7 +174,7 @@ export class QuestionService extends Disposable implements IQuestionService {
       agentId: 'main',
       question_id: p.questionId,
       dismissed_at: dismissedAt,
-    } as unknown as Event;
+    };
     this.eventService.publish(dismissedEvent);
 
     p.resolve(questionDismissedResult());
@@ -230,7 +230,7 @@ export class QuestionService extends Disposable implements IQuestionService {
       sessionId: p.sessionId,
       agentId: 'main',
       question_id: p.questionId,
-    } as unknown as Event;
+    };
     this.eventService.publish(expiredEvent);
 
     p.reject(new QuestionExpiredError(p.questionId, this._timeoutMs));

packages/server/test/services.test.ts

@@ -747,6 +747,66 @@ describe('WSBroadcastService (WS transport pump)', () => {
     bus2.dispose();
   });
 
+  it('reopens and replays a journal containing a question request event', async () => {
+    const sessionId = 'sid_question_journal';
+    const requestedEnvelope = {
+      type: 'event.question.requested',
+      seq: 2,
+      epoch: journalEpoch,
+      session_id: sessionId,
+      timestamp: '2026-08-02T00:00:00.000Z',
+      payload: {
+        type: 'event.question.requested',
+        agentId: 'main',
+        sessionId,
+        question_id: 'question_test',
+        session_id: sessionId,
+        questions: [{
+          id: 'q_0',
+          question: 'Which option?',
+          options: [{ id: 'opt_0_0', label: 'A', description: 'First option' }],
+          header: 'Choice',
+          allow_other: true,
+          other_label: 'Other',
+        }],
+        created_at: '2026-08-02T00:00:00.000Z',
+        expires_at: '2026-08-02T00:15:00.000Z',
+      },
+    };
+    writeJournal(sessionId, [
+      JSON.stringify(header()),
+      JSON.stringify(eventLine(sessionId, 1)),
+      JSON.stringify({ kind: 'event', seq: 2, envelope: requestedEnvelope }),
+    ]);
+
+    const bus = new EventService();
+    const broadcast = new WSBroadcastService(
+      bus,
+      testLogger,
+      new FakeSessionClients(),
+      new FakeConnectionRegistry(),
+      makeEnv(),
+    );
+
+    await expect(broadcast.getCursor(sessionId)).resolves.toMatchObject({
+      seq: 2,
+      epoch: journalEpoch,
+    });
+    await expect(broadcast.getBufferedSince(sessionId, { seq: 0, epoch: journalEpoch })).resolves.toMatchObject({
+      events: [expect.objectContaining({ seq: 1 }), expect.objectContaining({ seq: 2 })],
+      currentSeq: 2,
+      epoch: journalEpoch,
+    });
+    await expect(broadcast.getSnapshotState(sessionId)).resolves.toMatchObject({
+      seq: 2,
+      epoch: journalEpoch,
+    });
+
+    await broadcast.closeJournals();
+    broadcast.dispose();
+    bus.dispose();
+  });
+
   it('volatile events ride the watermark, are flagged, and are not journaled or replayed', async () => {
     const clients = new FakeSessionClients();
     const c = fakeConn();