agl 1.0.17 → 21.0.2

package/ts/interfaces.flexipc.ts

@@ -0,0 +1,2586 @@
+import * as plugins from './plugins.js';
+import {
+  controllerFilesystemIdentityMaximumComponents,
+  controllerProjectLimit,
+  type IControllerProjectFilesystemIdentity,
+} from './interfaces.projects.js';
+
+type TFlexCreateSessionOptions = plugins.flexharness.IFlexCreateSessionOptions;
+type TFlexMessage = plugins.flexharness.IFlexMessage;
+type TFlexMessagePage = plugins.flexharness.IFlexMessagePage;
+type TFlexPermissionRequest = plugins.flexharness.IFlexPermissionRequest;
+export type TFlexPromptQueueEntry = plugins.flexharness.IFlexPromptQueueEntry;
+type TFlexPromptOptions = plugins.flexharness.IFlexPromptOptions;
+type TFlexSession = plugins.flexharness.IFlexSession;
+type TFlexToolMessagePart = plugins.flexharness.IFlexToolMessagePart;
+type TFlexReasoningMessagePart = Extract<plugins.flexharness.TFlexMessagePart, { type: 'reasoning' }>;
+type TFlexTextMessagePart = Extract<plugins.flexharness.TFlexMessagePart, { type: 'text' }>;
+type TFlexUpdateSessionOptions = plugins.flexharness.IFlexUpdateSessionOptions;
+type TFlexPermissionDecision = plugins.flexharness.TFlexPermissionDecision;
+type TFlexPrompt = plugins.flexharness.TFlexPrompt;
+type TFlexProjectManagementRecord = plugins.flexharness.TFlexProjectManagementRecord;
+type TFlexProjectManagementSnapshot = plugins.flexharness.IFlexProjectManagementSnapshot;
+type TFlexProjectManagementTombstone = plugins.flexharness.IFlexProjectManagementTombstone;
+type TFlexProjectManagementWriteContext = plugins.flexharness.IFlexProjectManagementWriteContext;
+type TFlexJsonValue = plugins.flexharness.TJsonValue;
+export type TFlexSlashCommandDescriptor = plugins.flexharness.IFlexSlashCommandDescriptor;
+export type TFlexSessionReversionInfo = plugins.flexharness.IFlexSessionReversionInfo;
+export type TFlexTurnReversionFinalizedOutcome =
+  plugins.flexharness.TFlexTurnReversionFinalizedOutcome;
+export type TFlexTurnReversionCaptureInspectionV2 =
+  plugins.flexharness.TFlexTurnReversionCaptureInspectionV2;
+export type TFlexTurnReversionApplyInspection =
+  plugins.flexharness.IFlexTurnReversionApplyInspection;
+
+export const flexIpcProtocolVersion = 14 as const;
+export const flexIpcMaximumFrameBytes = 2 * 1024 * 1024;
+export const flexIpcMaximumPendingRequests = 64;
+export const flexIpcMaximumBrowserChannels = 128;
+export const flexIpcMaximumBrowserFrameBytes = 256 * 1024 + 4;
+export const flexIpcMaximumPendingBrowserFrames = 128;
+export const flexIpcMaximumPendingBrowserFrameBytes = 8 * 1024 * 1024;
+export const flexIpcMaximumChildJobs = 64;
+export const flexIpcMaximumPromptQueueEntries = 128;
+export const flexIpcMaximumQueuedSessionChanges = 256;
+export const flexIpcMaximumQueuedSessionChangeBytes = 8 * 1024 * 1024;
+export const flexIpcControlTimeoutMs = 35_000;
+export const flexIpcStartupTimeoutMs = 180_000;
+export const flexIpcDisposeTimeoutMs = 10_000;
+export const flexIpcSlashTimeoutMs = 30 * 60 * 1000;
+export const flexIpcMaximumHostTimeoutMs = 5 * 60 * 1000;
+export const flexIpcCancellationGraceTimeoutMs = 2_000;
+
+export interface IFlexProjectRecord {
+  projectId: string;
+  directory: string;
+  directoryIdentity?: IControllerProjectFilesystemIdentity;
+}
+
+export interface IFlexIdentityBoundProjectRecord extends IFlexProjectRecord {
+  directoryIdentity: IControllerProjectFilesystemIdentity;
+}
+
+export interface IFlexDatabaseDescriptor {
+  mongoDbUrl: string;
+  mongoDbName: string;
+}
+
+export interface IFlexServiceInit {
+  controllerId: string;
+  database: IFlexDatabaseDescriptor;
+  flexCredentialDirectory: string;
+  projects: IFlexProjectRecord[];
+}
+
+export interface IFlexBrowserResourceDescriptor {
+  resourceId: string;
+  attachmentRevision: number;
+}
+
+export interface IFlexBrowserChannelBinding {
+  projectId: string;
+  browserResourceId: string;
+  attachmentAuthorityId: string;
+  attachmentRevision: number;
+  actorId: string;
+  peerId: string;
+  role: 'agent';
+  source: 'flex';
+  scopeId: string;
+  channelId: string;
+  runId: string;
+  sessionId: { harnessId: 'flex'; nativeId: string };
+}
+
+export interface IFlexIntelligenceSessionId {
+  harnessId: 'opencode' | 'flex';
+  nativeId: string;
+}
+
+export interface IFlexIntelligenceChatSummary {
+  sessionId: IFlexIntelligenceSessionId;
+  title: string;
+  updatedAt: string;
+  isActive?: boolean;
+}
+
+export interface IFlexIntelligenceChatMessage {
+  role: string;
+  text: string;
+  timestamp?: string;
+}
+
+export interface IFlexIntelligenceChatTranscript {
+  sessionId: IFlexIntelligenceSessionId;
+  title: string;
+  messages: IFlexIntelligenceChatMessage[];
+  totalMessages?: number;
+}
+
+export interface IFlexIntelligenceResult {
+  answer: string;
+  scratchpad: string;
+  model: string;
+}
+
+export interface IFlexTurnReversionBaseRequest {
+  scopeId: string;
+  storageKey: string;
+  sessionId: string;
+  runId: string;
+  captureId: string;
+}
+
+export interface IFlexTurnReversionApplyRequest extends IFlexTurnReversionBaseRequest {
+  reference: TFlexJsonValue;
+  operationId: string;
+  direction: 'undo' | 'redo';
+}
+
+export interface IFlexTurnReversionReleaseRequest extends IFlexTurnReversionBaseRequest {
+  reference: TFlexJsonValue;
+}
+
+export interface IFlexGitWorktreeDescriptor {
+  worktreeId: string;
+  projectId: string;
+  sessionId: string;
+  path: string;
+  repositoryId: string;
+  createdAt: string;
+}
+
+export type TFlexIntelligenceJobStatus = 'running' | 'completed' | 'failed' | 'cancelled';
+
+export interface IFlexHostRequestMap {
+  'reversion.prepare': {
+    request: IFlexTurnReversionBaseRequest;
+    response: { prepared: true };
+  };
+  'reversion.inspect-capture': {
+    request: IFlexTurnReversionBaseRequest;
+    response: TFlexTurnReversionCaptureInspectionV2;
+  };
+  'reversion.finalize': {
+    request: IFlexTurnReversionBaseRequest;
+    response: TFlexTurnReversionFinalizedOutcome;
+  };
+  'reversion.inspect-apply': {
+    request: IFlexTurnReversionApplyRequest;
+    response: TFlexTurnReversionApplyInspection;
+  };
+  'reversion.apply': {
+    request: IFlexTurnReversionApplyRequest;
+    response: { applied: true };
+  };
+  'reversion.release': {
+    request: IFlexTurnReversionReleaseRequest;
+    response: { released: true };
+  };
+  'git.worktree.create': {
+    request: { scopeId: string; sessionId: string };
+    response: { worktree: IFlexGitWorktreeDescriptor };
+  };
+  'git.worktree.list': {
+    request: { scopeId: string; sessionId: string };
+    response: { worktrees: IFlexGitWorktreeDescriptor[] };
+  };
+  'git.worktree.remove': {
+    request: {
+      scopeId: string;
+      sessionId: string;
+      worktreeId: string;
+      compensate?: true;
+    };
+    response: { removed: true };
+  };
+  'crossharness.chats.list': {
+    request: { capabilityToken: string; limit: number };
+    response: { chats: IFlexIntelligenceChatSummary[] };
+  };
+  'crossharness.chat.read': {
+    request: {
+      capabilityToken: string;
+      sessionId: IFlexIntelligenceSessionId;
+      limit: number;
+      maxChars: number;
+    };
+    response: { transcript: IFlexIntelligenceChatTranscript };
+  };
+  'project-management.load': {
+    request: {
+      storageKey: string;
+      sessionId: string;
+      sessionGenerationId: string;
+      sessionGenerationSequence: number;
+    };
+    response: { record: TFlexProjectManagementRecord | null };
+  };
+  'project-management.save': {
+    request: {
+      storageKey: string;
+      sessionId: string;
+      snapshot: TFlexProjectManagementSnapshot;
+      expectedRevision: number;
+      writeContext: TFlexProjectManagementWriteContext;
+    };
+    response: TFlexProjectManagementCommitResult;
+  };
+  'project-management.tombstone': {
+    request: {
+      storageKey: string;
+      sessionId: string;
+      tombstone: TFlexProjectManagementTombstone;
+      expectedRevision: number;
+    };
+    response: TFlexProjectManagementCommitResult;
+  };
+  'project-management.purge': {
+    request: { storageKey: string };
+    response: { purged: true };
+  };
+  'browser.resources.resolve': {
+    request: { scopeId: string; sessionId: string; runId: string };
+    response: { resources: IFlexBrowserResourceDescriptor[] };
+  };
+  'browser.channel.open': {
+    request: {
+      scopeId: string;
+      sessionId: string;
+      runId: string;
+      resourceId: string;
+      attachmentRevision: number;
+      channelId: string;
+    };
+    response: { binding: IFlexBrowserChannelBinding; capabilityToken: string };
+  };
+  'browser.channel.close': {
+    request: { channelId: string };
+    response: { closed: true };
+  };
+}
+
+export type TFlexProjectManagementCommitResult =
+  | { committed: true }
+  | { committed: false; actualRevision: number };
+
+export type TFlexHostRequestMethod = keyof IFlexHostRequestMap;
+export type TFlexHostRequest<TMethod extends TFlexHostRequestMethod> =
+  IFlexHostRequestMap[TMethod]['request'];
+export type TFlexHostResponse<TMethod extends TFlexHostRequestMethod> =
+  IFlexHostRequestMap[TMethod]['response'];
+
+export type TFlexServiceState =
+  | 'starting'
+  | 'ready'
+  | 'unsupported'
+  | 'failed'
+  | 'stopping'
+  | 'stopped';
+
+export type TFlexServiceStatusCode =
+  | 'UNSUPPORTED_RUNTIME'
+  | 'INITIALIZATION_FAILED'
+  | 'SERVICE_STOPPED';
+
+export interface IFlexServiceStatus {
+  state: TFlexServiceState;
+  ready: boolean;
+  code?: TFlexServiceStatusCode;
+  startedAt?: string;
+}
+
+export type TFlexPublicConnectionState =
+  | 'pending'
+  | 'active'
+  | 'deleting'
+  | 'reauthRequired';
+
+export interface IFlexPublicAccountSummary {
+  providerId: string;
+  authKind: 'chatgptOAuth';
+  accountId?: string;
+  email?: string;
+  plan?: string;
+}
+
+export interface IFlexPublicProviderConnection {
+  loginId: string;
+  providerId: 'openai';
+  status: TFlexPublicConnectionState;
+  account?: IFlexPublicAccountSummary;
+}
+
+/** Private child-to-controller projection. It is never exposed by controller RPC. */
+export interface IFlexOpenCodeOAuthAuth {
+  type: 'oauth';
+  access: string;
+  refresh: string;
+  expires: number;
+  accountId?: string;
+}
+
+export interface IFlexPublicProviderModel {
+  providerId: 'openai';
+  modelId: string;
+  displayName: string;
+  description: string;
+  hidden: boolean;
+  reasoningEfforts: Array<{ effort: string; description: string }>;
+  defaultReasoningEffort: string;
+  inputModalities: Array<'text' | 'image' | 'audio'>;
+  supportsPersonality: boolean;
+  serviceTiers: Array<{ id: string; name: string; description: string }>;
+  defaultServiceTier?: string;
+  isDefault: boolean;
+}
+
+export interface IFlexPublicProviderRateLimitWindow {
+  usedPercent: number;
+  limitWindowSeconds: number;
+  resetAfterSeconds: number;
+  resetsAt: number;
+}
+
+export interface IFlexPublicProviderRateLimitDetails {
+  allowed: boolean;
+  limitReached: boolean;
+  primaryWindow?: IFlexPublicProviderRateLimitWindow;
+  secondaryWindow?: IFlexPublicProviderRateLimitWindow;
+}
+
+export interface IFlexPublicProviderAdditionalRateLimit {
+  limitName: string;
+  meteredFeature: string;
+  rateLimit?: IFlexPublicProviderRateLimitDetails;
+}
+
+export interface IFlexPublicProviderAccountRateLimits {
+  providerId: 'openai';
+  plan: string;
+  observedAt: string;
+  rateLimit?: IFlexPublicProviderRateLimitDetails;
+  additionalRateLimits: IFlexPublicProviderAdditionalRateLimit[];
+  rateLimitReachedType?: string;
+  rateLimitResetCreditsAvailableCount?: number;
+}
+
+export interface IFlexModelChoice {
+  providerConnectionId: string;
+  modelId: string;
+  variant?: string;
+}
+
+export interface IFlexJobAdmission {
+  jobId: string;
+}
+
+export interface IFlexSessionListResult {
+  sessions: TFlexSession[];
+  total: number;
+  truncated: boolean;
+}
+
+export type TFlexSlashExecutionResult =
+  | plugins.flexharness.IFlexSlashCommandNotCommandResult
+  | plugins.flexharness.IFlexSlashCommandMalformedResult
+  | plugins.flexharness.IFlexSlashCommandUnknownResult
+  | plugins.flexharness.IFlexSlashCommandOperationResult
+  | plugins.flexharness.IFlexSlashCommandHandlerResult
+  | {
+      type: 'prompt-admission';
+      name: string;
+      admission: { queueId: string; runId: string };
+    };
+
+export interface IFlexRequestMap {
+  'service.status': {
+    request: Record<string, never>;
+    response: IFlexServiceStatus;
+  };
+  'project.replaceAll': {
+    request: { projects: IFlexProjectRecord[] };
+    response: { replaced: true; retired: number };
+  };
+  'project.register': {
+    request: { project: IFlexIdentityBoundProjectRecord };
+    response: { registered: true };
+  };
+  'project.remove': {
+    request: { project: IFlexIdentityBoundProjectRecord };
+    response: { removed: true };
+  };
+  'intelligence.start': {
+    request: {
+      scopeId: string;
+      sourceSessionId: IFlexIntelligenceSessionId;
+      question: string;
+      scratchpad: string;
+      model: IFlexModelChoice;
+      capabilityToken: string;
+    };
+    response: { jobId: string; workerSessionId: string };
+  };
+  'intelligence.get': {
+    request: { scopeId: string; jobId: string; capabilityToken: string };
+    response: {
+      status: TFlexIntelligenceJobStatus;
+      workerSessionId: string;
+      result?: IFlexIntelligenceResult;
+      error?: string;
+    };
+  };
+  'intelligence.cancel': {
+    request: { scopeId: string; capabilityToken: string };
+    response: { cancelled: boolean };
+  };
+  'session.list': {
+    request: { scopeId: string; offset?: number; limit?: number };
+    response: IFlexSessionListResult;
+  };
+  'session.create': {
+    request: { scopeId: string; options?: TFlexCreateSessionOptions };
+    response: TFlexSession;
+  };
+  'session.get': {
+    request: { scopeId: string; sessionId: string };
+    response: TFlexSession;
+  };
+  'session.update': {
+    request: { scopeId: string; sessionId: string; options: TFlexUpdateSessionOptions };
+    response: TFlexSession;
+  };
+  'session.delete': {
+    request: { scopeId: string; sessionId: string };
+    response: { deleted: true };
+  };
+  'session.compact': {
+    request: { scopeId: string; sessionId: string; model?: IFlexModelChoice };
+    response: { compacted: true };
+  };
+  'session.reversion.info': {
+    request: { scopeId: string; sessionId: string };
+    response: TFlexSessionReversionInfo;
+  };
+  'slash.list': {
+    request: { scopeId: string; sessionId: string };
+    response: { commands: TFlexSlashCommandDescriptor[] };
+  };
+  'slash.execute': {
+    request: {
+      scopeId: string;
+      sessionId: string;
+      input: string;
+      model?: IFlexModelChoice;
+    };
+    response: TFlexSlashExecutionResult;
+  };
+  'message.page': {
+    request: { scopeId: string; sessionId: string; limit?: number; before?: string };
+    response: TFlexMessagePage;
+  };
+  'message.get': {
+    request: { scopeId: string; sessionId: string; messageId: string };
+    response: TFlexMessage;
+  };
+  'prompt.start': {
+    request: {
+      scopeId: string;
+      sessionId: string;
+      prompt: TFlexPrompt;
+      options?: TFlexPromptOptions;
+      model?: IFlexModelChoice;
+      upload?: {
+        operationId: string;
+        directory: string;
+      };
+    };
+    response: { queueId: string; runId: string };
+  };
+  'prompt.acknowledge': {
+    request: { scopeId: string; sessionId: string; queueId: string; runId: string };
+    response: { acknowledged: true };
+  };
+  'prompt.get': {
+    request: { scopeId: string; sessionId: string; queueId: string };
+    response: { entry: TFlexPromptQueueEntry };
+  };
+  'prompt.list': {
+    request: { scopeId: string; sessionId: string };
+    response: { entries: TFlexPromptQueueEntry[] };
+  };
+  'prompt.cancel': {
+    request: { scopeId: string; sessionId: string; queueId: string };
+    response: { accepted: boolean };
+  };
+  'permission.list': {
+    request: { scopeId: string; sessionId?: string; familyRootSessionId?: string };
+    response: { permissions: TFlexPermissionRequest[] };
+  };
+  'permission.respond': {
+    request: {
+      scopeId: string;
+      sessionId: string;
+      permissionId: string;
+      decision: TFlexPermissionDecision;
+    };
+    response: { accepted: true };
+  };
+  'provider.list': {
+    request: Record<string, never>;
+    response: {
+      providers: Array<{ providerId: 'openai'; displayName: string; loginFlow: 'device' }>;
+    };
+  };
+  'provider.login.begin': {
+    request: { providerId: 'openai' };
+    response: {
+      loginId: string;
+      verificationUrl: string;
+      userCode: string;
+      status: 'pending';
+    };
+  };
+  'provider.login.status': {
+    request: { loginId: string };
+    response: IFlexPublicProviderConnection;
+  };
+  'provider.login.cancel': {
+    request: { loginId: string };
+    response: { canceled: boolean };
+  };
+  'provider.connection.list': {
+    request: Record<string, never>;
+    response: { connections: IFlexPublicProviderConnection[] };
+  };
+  'provider.connection.opencode-auth.get': {
+    request: { providerConnectionId: string };
+    response: { auth: IFlexOpenCodeOAuthAuth };
+  };
+  'provider.connection.logout.prepare': {
+    request: { providerConnectionId: string };
+    response: { accepted: true };
+  };
+  'provider.connection.logout': {
+    request: { providerConnectionId: string };
+    response: { accepted: true };
+  };
+  'provider.connection.ratelimits.get': {
+    request: { providerConnectionId: string };
+    response: { rateLimits: IFlexPublicProviderAccountRateLimits };
+  };
+  'provider.models.refresh': {
+    request: { providerConnectionId: string };
+    response: IFlexJobAdmission;
+  };
+  'model.choice.get': {
+    request: { scopeId: string };
+    response: { choice: IFlexModelChoice | null };
+  };
+  'model.choice.set': {
+    request: { scopeId: string; choice: IFlexModelChoice };
+    response: { choice: IFlexModelChoice };
+  };
+  'model.choice.validate': {
+    request: { choice: IFlexModelChoice };
+    response: { valid: true };
+  };
+}
+
+export type TFlexRequestMethod = keyof IFlexRequestMap;
+export type TFlexRequest<TMethod extends TFlexRequestMethod> = IFlexRequestMap[TMethod]['request'];
+export type TFlexResponse<TMethod extends TFlexRequestMethod> = IFlexRequestMap[TMethod]['response'];
+
+export interface IFlexIpcInitMessage {
+  version: typeof flexIpcProtocolVersion;
+  type: 'init';
+  init: IFlexServiceInit;
+}
+
+export interface IFlexIpcRequestMessage {
+  version: typeof flexIpcProtocolVersion;
+  type: 'request';
+  requestId: string;
+  method: TFlexRequestMethod;
+  payload: unknown;
+}
+
+export interface IFlexIpcRequestCancelMessage {
+  version: typeof flexIpcProtocolVersion;
+  type: 'request.cancel';
+  requestId: string;
+}
+
+export interface IFlexIpcDisposeMessage {
+  version: typeof flexIpcProtocolVersion;
+  type: 'dispose';
+  requestId: string;
+}
+
+export type TFlexIpcHostResponseMessage = {
+  version: typeof flexIpcProtocolVersion;
+  type: 'host.response';
+  requestId: string;
+} & (
+  | { ok: true; result: unknown }
+  | { ok: false; error: IFlexServiceError }
+);
+
+export interface IFlexIpcParentBrowserFrameMessage {
+  version: typeof flexIpcProtocolVersion;
+  type: 'browser.channel.frame';
+  channelId: string;
+  dataBase64: string;
+}
+
+export interface IFlexIpcBrowserChannelClosedMessage {
+  version: typeof flexIpcProtocolVersion;
+  type: 'browser.channel.closed';
+  channelId: string;
+}
+
+export type TFlexParentMessage =
+  | IFlexIpcInitMessage
+  | IFlexIpcRequestMessage
+  | IFlexIpcRequestCancelMessage
+  | IFlexIpcDisposeMessage
+  | TFlexIpcHostResponseMessage
+  | IFlexIpcParentBrowserFrameMessage
+  | IFlexIpcBrowserChannelClosedMessage;
+
+export type TFlexServiceErrorCode =
+  | 'INVALID_REQUEST'
+  | 'NOT_READY'
+  | 'NOT_FOUND'
+  | 'CONFLICT'
+  | 'BUSY'
+  | 'TIMEOUT'
+  | 'ABORTED'
+  | 'OUTCOME_UNKNOWN'
+  | 'SLASH_UNAVAILABLE'
+  | 'LIMIT_EXCEEDED'
+  | 'STALE_RUN'
+  | 'PROVIDER_LOGIN_FAILED'
+  | 'PROVIDER_REAUTH_REQUIRED'
+  | 'MODEL_CATALOG_REQUIRED'
+  | 'UNSUPPORTED_RUNTIME'
+  | 'INTERNAL';
+
+export const flexServiceErrorMessages: Readonly<Record<TFlexServiceErrorCode, string>> = {
+  INVALID_REQUEST: 'The Flex request is invalid.',
+  NOT_READY: 'The Flex service is not ready.',
+  NOT_FOUND: 'The requested Flex resource was not found.',
+  CONFLICT: 'The Flex operation conflicted with a concurrent change.',
+  BUSY: 'The Flex resource is busy.',
+  TIMEOUT: 'The Flex operation timed out.',
+  ABORTED: 'The Flex operation was aborted.',
+  OUTCOME_UNKNOWN: 'The Flex operation outcome is unknown.',
+  SLASH_UNAVAILABLE: 'The Flex slash command is unavailable.',
+  LIMIT_EXCEEDED: 'The Flex service limit was reached.',
+  STALE_RUN: 'The requested Flex run is no longer current.',
+  PROVIDER_LOGIN_FAILED: 'The provider login did not complete.',
+  PROVIDER_REAUTH_REQUIRED: 'The provider connection requires authentication.',
+  MODEL_CATALOG_REQUIRED: 'The provider model catalog must be refreshed.',
+  UNSUPPORTED_RUNTIME: 'The Flex child runtime is unsupported.',
+  INTERNAL: 'The Flex operation failed.',
+};
+
+export interface IFlexServiceError {
+  name: 'FlexServiceError';
+  code: TFlexServiceErrorCode;
+  message: string;
+}
+
+export interface IFlexIpcStatusMessage {
+  version: typeof flexIpcProtocolVersion;
+  type: 'status';
+  status: IFlexServiceStatus;
+}
+
+export type TFlexIpcResponseMessage = {
+  version: typeof flexIpcProtocolVersion;
+  type: 'response';
+  requestId: string;
+} & (
+  | { ok: true; result: unknown }
+  | { ok: false; error: IFlexServiceError }
+);
+
+export type TFlexJobKind = 'provider.models';
+
+export type TFlexChildEvent =
+  | {
+      type: 'session.history.changed';
+      scopeId: string;
+      sessionId: string;
+      direction: 'undo' | 'redo' | 'branch';
+      runId?: string;
+    }
+  | {
+      type: 'sessions.changed';
+      scopeId?: string;
+      sessionId?: string;
+      coalesced: boolean;
+    }
+  | {
+      type: 'permissions.changed';
+      scopeId: string;
+      sessionId: string;
+    }
+  | {
+      type: 'tool.updated';
+      scopeId: string;
+      sessionId: string;
+      runId: string;
+      messageId: string;
+      messageIndex: number;
+      partIndex: number;
+      sequence: number;
+      timestamp: string;
+      part: TFlexToolMessagePart;
+    }
+  | {
+      type: 'reasoning.updated';
+      scopeId: string;
+      sessionId: string;
+      runId: string;
+      messageId: string;
+      messageIndex: number;
+      partIndex: number;
+      sequence: number;
+      timestamp: string;
+      part: TFlexReasoningMessagePart;
+    }
+  | {
+      type: 'text.updated';
+      scopeId: string;
+      sessionId: string;
+      runId: string;
+      messageId: string;
+      messageIndex: number;
+      partIndex: number;
+      sequence: number;
+      timestamp: string;
+      status: 'running' | 'completed';
+      part: TFlexTextMessagePart;
+    }
+  | {
+      type: 'prompt.queued';
+      scopeId: string;
+      sessionId: string;
+      queueId: string;
+      runId?: never;
+      entry: TFlexPromptQueueEntry;
+    }
+  | {
+      type: 'prompt.started' | 'prompt.running' | 'prompt.finished';
+      scopeId: string;
+      sessionId: string;
+      queueId: string;
+      runId: string;
+      entry: TFlexPromptQueueEntry;
+    }
+  | {
+      type: 'prompt.message-bound';
+      scopeId: string;
+      sessionId: string;
+      queueId: string;
+      runId: string;
+      messageId: string;
+    }
+  | {
+      type: 'job.finished';
+      jobId: string;
+      kind: TFlexJobKind;
+      status: 'completed' | 'failed' | 'cancelled';
+      models?: IFlexPublicProviderModel[];
+    }
+  | {
+      type: 'provider.connection.changed';
+      connection: IFlexPublicProviderConnection;
+    };
+
+export interface IFlexIpcEventMessage {
+  version: typeof flexIpcProtocolVersion;
+  type: 'event';
+  event: TFlexChildEvent;
+}
+
+export interface IFlexIpcHostRequestMessage {
+  version: typeof flexIpcProtocolVersion;
+  type: 'host.request';
+  requestId: string;
+  method: TFlexHostRequestMethod;
+  payload: unknown;
+  timeoutMs: number;
+}
+
+export interface IFlexIpcHostCancelMessage {
+  version: typeof flexIpcProtocolVersion;
+  type: 'host.cancel';
+  requestId: string;
+}
+
+export interface IFlexIpcHostResponseAcknowledgementMessage {
+  version: typeof flexIpcProtocolVersion;
+  type: 'host.response.acknowledge';
+  requestId: string;
+}
+
+export interface IFlexIpcChildBrowserFrameMessage {
+  version: typeof flexIpcProtocolVersion;
+  type: 'browser.channel.frame';
+  channelId: string;
+  dataBase64: string;
+}
+
+export type TFlexChildMessage =
+  | IFlexIpcStatusMessage
+  | TFlexIpcResponseMessage
+  | IFlexIpcEventMessage
+  | IFlexIpcHostRequestMessage
+  | IFlexIpcHostCancelMessage
+  | IFlexIpcHostResponseAcknowledgementMessage
+  | IFlexIpcChildBrowserFrameMessage;
+
+const requestMethods: ReadonlySet<string> = new Set<TFlexRequestMethod>([
+  'service.status',
+  'project.replaceAll',
+  'project.register',
+  'project.remove',
+  'intelligence.start',
+  'intelligence.get',
+  'intelligence.cancel',
+  'session.list',
+  'session.create',
+  'session.get',
+  'session.update',
+  'session.delete',
+  'session.compact',
+  'session.reversion.info',
+  'slash.list',
+  'slash.execute',
+  'message.page',
+  'message.get',
+  'prompt.start',
+  'prompt.acknowledge',
+  'prompt.get',
+  'prompt.list',
+  'prompt.cancel',
+  'permission.list',
+  'permission.respond',
+  'provider.list',
+  'provider.login.begin',
+  'provider.login.status',
+  'provider.login.cancel',
+  'provider.connection.list',
+  'provider.connection.opencode-auth.get',
+  'provider.connection.logout.prepare',
+  'provider.connection.logout',
+  'provider.connection.ratelimits.get',
+  'provider.models.refresh',
+  'model.choice.get',
+  'model.choice.set',
+  'model.choice.validate',
+]);
+const hostRequestMethods: ReadonlySet<string> = new Set<TFlexHostRequestMethod>([
+  'reversion.prepare',
+  'reversion.inspect-capture',
+  'reversion.finalize',
+  'reversion.inspect-apply',
+  'reversion.apply',
+  'reversion.release',
+  'git.worktree.create',
+  'git.worktree.list',
+  'git.worktree.remove',
+  'crossharness.chats.list',
+  'crossharness.chat.read',
+  'project-management.load',
+  'project-management.save',
+  'project-management.tombstone',
+  'project-management.purge',
+  'browser.resources.resolve',
+  'browser.channel.open',
+  'browser.channel.close',
+]);
+const serviceStates: ReadonlySet<string> = new Set<TFlexServiceState>([
+  'starting', 'ready', 'unsupported', 'failed', 'stopping', 'stopped',
+]);
+const serviceStatusCodes: ReadonlySet<string> = new Set<TFlexServiceStatusCode>([
+  'UNSUPPORTED_RUNTIME', 'INITIALIZATION_FAILED', 'SERVICE_STOPPED',
+]);
+const serviceErrorCodes: ReadonlySet<string> = new Set<TFlexServiceErrorCode>(
+  Object.keys(flexServiceErrorMessages) as TFlexServiceErrorCode[],
+);
+const identifierPattern = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,511}$/u;
+const projectIdPattern = /^[A-Za-z0-9][A-Za-z0-9_-]{0,127}$/u;
+const requestIdPattern = /^[A-Za-z0-9_-]{22}$/u;
+const qualifiedIdPattern = /^flex:(?:job|provider:openai):[A-Za-z0-9_-]{22}$/u;
+const intelligenceCapabilityTokenPattern = /^[A-Za-z0-9_-]{43}$/u;
+
+export const isFlexPlainObject = (valueArg: unknown): valueArg is Record<string, unknown> =>
+  typeof valueArg === 'object'
+  && valueArg !== null
+  && !Array.isArray(valueArg)
+  && (
+    Object.getPrototypeOf(valueArg) === Object.prototype
+    || Object.getPrototypeOf(valueArg) === null
+  );
+
+export const hasFlexExactKeys = (
+  valueArg: Record<string, unknown>,
+  requiredKeysArg: readonly string[],
+  optionalKeysArg: readonly string[] = [],
+): boolean => {
+  const keys = Object.keys(valueArg);
+  return requiredKeysArg.every((key) => Object.hasOwn(valueArg, key))
+    && keys.every((key) => requiredKeysArg.includes(key) || optionalKeysArg.includes(key));
+};
+
+const isBoundedString = (
+  valueArg: unknown,
+  maximumBytesArg: number,
+  allowEmptyArg = false,
+): valueArg is string => typeof valueArg === 'string'
+  && (allowEmptyArg || valueArg.length > 0)
+  && Buffer.byteLength(valueArg, 'utf8') <= maximumBytesArg;
+
+const isIdentifier = (valueArg: unknown): valueArg is string =>
+  isBoundedString(valueArg, 512) && identifierPattern.test(valueArg);
+
+const isRequestId = (valueArg: unknown): valueArg is string =>
+  typeof valueArg === 'string' && requestIdPattern.test(valueArg);
+
+const isChannelId = (valueArg: unknown): valueArg is string =>
+  typeof valueArg === 'string' && identifierPattern.test(valueArg);
+
+const isCanonicalBrowserFrame = (valueArg: unknown): valueArg is string => {
+  if (typeof valueArg !== 'string' || valueArg.length === 0) return false;
+  const bytes = Buffer.from(valueArg, 'base64');
+  return bytes.byteLength >= 1
+    && bytes.byteLength <= flexIpcMaximumBrowserFrameBytes
+    && bytes.toString('base64') === valueArg;
+};
+
+const isQualifiedId = (valueArg: unknown): valueArg is string =>
+  typeof valueArg === 'string' && qualifiedIdPattern.test(valueArg);
+
+const isIntelligenceCapabilityToken = (valueArg: unknown): valueArg is string =>
+  typeof valueArg === 'string' && intelligenceCapabilityTokenPattern.test(valueArg);
+
+const isIsoDate = (valueArg: unknown): valueArg is string =>
+  isBoundedString(valueArg, 64)
+  && Number.isFinite(Date.parse(valueArg))
+  && new Date(valueArg).toISOString() === valueArg;
+
+const isNonNegativeInteger = (valueArg: unknown): valueArg is number =>
+  Number.isSafeInteger(valueArg) && (valueArg as number) >= 0;
+
+const isFlexIntelligenceSessionId = (
+  valueArg: unknown,
+): valueArg is IFlexIntelligenceSessionId => isFlexPlainObject(valueArg)
+  && hasFlexExactKeys(valueArg, ['harnessId', 'nativeId'])
+  && (valueArg.harnessId === 'opencode' || valueArg.harnessId === 'flex')
+  && isIdentifier(valueArg.nativeId);
+
+const isFlexIntelligenceChatSummary = (
+  valueArg: unknown,
+): valueArg is IFlexIntelligenceChatSummary => isFlexPlainObject(valueArg)
+  && hasFlexExactKeys(valueArg, ['sessionId', 'title', 'updatedAt'], ['isActive'])
+  && isFlexIntelligenceSessionId(valueArg.sessionId)
+  && isBoundedString(valueArg.title, 4096, true)
+  && isIsoDate(valueArg.updatedAt)
+  && (valueArg.isActive === undefined || typeof valueArg.isActive === 'boolean');
+
+const isFlexIntelligenceChatMessage = (
+  valueArg: unknown,
+): valueArg is IFlexIntelligenceChatMessage => isFlexPlainObject(valueArg)
+  && hasFlexExactKeys(valueArg, ['role', 'text'], ['timestamp'])
+  && isBoundedString(valueArg.role, 128)
+  && isBoundedString(valueArg.text, 16 * 1024, true)
+  && (valueArg.timestamp === undefined || isIsoDate(valueArg.timestamp));
+
+const isFlexIntelligenceChatTranscript = (
+  valueArg: unknown,
+): valueArg is IFlexIntelligenceChatTranscript => isFlexPlainObject(valueArg)
+  && hasFlexExactKeys(valueArg, ['sessionId', 'title', 'messages'], ['totalMessages'])
+  && isFlexIntelligenceSessionId(valueArg.sessionId)
+  && isBoundedString(valueArg.title, 4096, true)
+  && Array.isArray(valueArg.messages)
+  && valueArg.messages.length <= 50
+  && valueArg.messages.every(isFlexIntelligenceChatMessage)
+  && (valueArg.totalMessages === undefined || isNonNegativeInteger(valueArg.totalMessages))
+  && Buffer.byteLength(JSON.stringify(valueArg), 'utf8') <= 256 * 1024;
+
+const isFlexIntelligenceResult = (valueArg: unknown): valueArg is IFlexIntelligenceResult => (
+  isFlexPlainObject(valueArg)
+  && hasFlexExactKeys(valueArg, ['answer', 'scratchpad', 'model'])
+  && isBoundedString(valueArg.answer, 128 * 1024, true)
+  && isBoundedString(valueArg.scratchpad, 128 * 1024, true)
+  && valueArg.answer.length <= 32_768
+  && valueArg.scratchpad.length <= 32_768
+  && valueArg.model === 'openai/gpt-5.6-luna'
+);
+
+const isJsonValue = (valueArg: unknown, depthArg = 0): boolean => {
+  if (depthArg > 20) return false;
+  if (
+    valueArg === null
+    || typeof valueArg === 'string'
+    || typeof valueArg === 'boolean'
+    || (typeof valueArg === 'number' && Number.isFinite(valueArg))
+  ) return true;
+  if (Array.isArray(valueArg)) {
+    return valueArg.length <= 4096 && valueArg.every((entry) => isJsonValue(entry, depthArg + 1));
+  }
+  if (!isFlexPlainObject(valueArg) || Object.keys(valueArg).length > 4096) return false;
+  return Object.values(valueArg).every((entry) => isJsonValue(entry, depthArg + 1));
+};
+
+const isFlexSessionGeneration = (valueArg: Record<string, unknown>): boolean =>
+  isBoundedString(
+    valueArg.sessionGenerationId,
+    plugins.flexharness.FLEX_SESSION_GENERATION_ID_MAX_BYTES,
+  )
+  && isNonNegativeInteger(valueArg.sessionGenerationSequence)
+  && Number(valueArg.sessionGenerationSequence) >= 1;
+
+const isFlexProjectManagementRecord = (
+  valueArg: unknown,
+): valueArg is TFlexProjectManagementRecord => {
+  try {
+    plugins.flexharness.assertFlexProjectManagementRecord(valueArg);
+    return true;
+  } catch {
+    return false;
+  }
+};
+
+const isFlexProjectManagementSnapshot = (
+  valueArg: unknown,
+): valueArg is TFlexProjectManagementSnapshot => {
+  try {
+    plugins.flexharness.assertFlexProjectManagementSnapshot(valueArg);
+    return true;
+  } catch {
+    return false;
+  }
+};
+
+const isFlexProjectManagementTombstone = (
+  valueArg: unknown,
+): valueArg is TFlexProjectManagementTombstone => {
+  try {
+    plugins.flexharness.assertFlexProjectManagementTombstone(valueArg);
+    return true;
+  } catch {
+    return false;
+  }
+};
+
+const isFlexProjectManagementWriteContext = (
+  valueArg: unknown,
+): valueArg is TFlexProjectManagementWriteContext => isFlexPlainObject(valueArg)
+  && hasFlexExactKeys(valueArg, ['actor'], ['runId', 'agent', 'toolCallId'])
+  && (valueArg.actor === 'agent' || valueArg.actor === 'application')
+  && ['runId', 'agent', 'toolCallId'].every((key) => (
+    valueArg[key] === undefined || isBoundedString(valueArg[key], 512)
+  ));
+
+const isFlexProjectManagementCommitResult = (
+  valueArg: unknown,
+): valueArg is TFlexProjectManagementCommitResult => isFlexPlainObject(valueArg)
+  && (
+    (hasFlexExactKeys(valueArg, ['committed']) && valueArg.committed === true)
+    || (
+      hasFlexExactKeys(valueArg, ['committed', 'actualRevision'])
+      && valueArg.committed === false
+      && isNonNegativeInteger(valueArg.actualRevision)
+    )
+  );
+
+export const isFlexProjectRecord = (valueArg: unknown): valueArg is IFlexProjectRecord => {
+  if (!isFlexPlainObject(valueArg) || !hasFlexExactKeys(
+    valueArg,
+    ['projectId', 'directory'],
+    ['directoryIdentity'],
+  )) {
+    return false;
+  }
+  if (
+    typeof valueArg.projectId !== 'string'
+    || !projectIdPattern.test(valueArg.projectId)
+    || !isBoundedString(valueArg.directory, 4096)
+    || valueArg.directory.includes('\0')
+    || !plugins.path.isAbsolute(valueArg.directory)
+    || plugins.path.normalize(valueArg.directory) !== valueArg.directory
+  ) return false;
+  if (valueArg.directoryIdentity === undefined) return true;
+  const directoryIdentity = valueArg.directoryIdentity;
+  if (!isFlexPlainObject(directoryIdentity) || !Array.isArray(directoryIdentity.ancestry)) {
+    return false;
+  }
+  const ancestry = directoryIdentity.ancestry;
+  return hasFlexExactKeys(directoryIdentity, ['ancestry'])
+    && ancestry.length === 1
+      + valueArg.directory.slice(1).split('/').filter(Boolean).length
+    && ancestry.length <= controllerFilesystemIdentityMaximumComponents
+    && ancestry.every((component) => (
+      isFlexPlainObject(component)
+      && hasFlexExactKeys(component, ['device', 'inode', 'type'])
+      && typeof component.device === 'string'
+      && /^(?:0|[1-9][0-9]{0,31})$/u.test(component.device)
+      && typeof component.inode === 'string'
+      && /^(?:0|[1-9][0-9]{0,31})$/u.test(component.inode)
+      && component.type === 'directory'
+    ));
+};
+
+export const isFlexIdentityBoundProjectRecord = (
+  valueArg: unknown,
+): valueArg is IFlexIdentityBoundProjectRecord => isFlexProjectRecord(valueArg)
+  && valueArg.directoryIdentity !== undefined;
+
+export const isFlexDatabaseDescriptor = (
+  valueArg: unknown,
+): valueArg is IFlexDatabaseDescriptor => isFlexPlainObject(valueArg)
+  && hasFlexExactKeys(valueArg, ['mongoDbUrl', 'mongoDbName'])
+  && isBoundedString(valueArg.mongoDbUrl, 4096)
+  && /^(?:mongodb|mongodb\+srv):\/\//u.test(valueArg.mongoDbUrl)
+  && typeof valueArg.mongoDbName === 'string'
+  && /^[A-Za-z0-9_-]{1,63}$/u.test(valueArg.mongoDbName);
+
+const isFlexCredentialDirectory = (valueArg: unknown): valueArg is string => {
+  if (
+    !isBoundedString(valueArg, 4096)
+    || !valueArg.startsWith('/')
+    || valueArg.includes('\0')
+    || valueArg === '/'
+  ) return false;
+  const segments = valueArg.split('/');
+  return !segments.some((segment, index) => (
+    index > 0 && (segment === '' || segment === '.' || segment === '..')
+  ));
+};
+
+export const isFlexServiceInit = (valueArg: unknown): valueArg is IFlexServiceInit => {
+  if (
+    !isFlexPlainObject(valueArg)
+    || !hasFlexExactKeys(valueArg, [
+      'controllerId', 'database', 'flexCredentialDirectory', 'projects',
+    ])
+    || !isIdentifier(valueArg.controllerId)
+    || !isFlexDatabaseDescriptor(valueArg.database)
+    || !isFlexCredentialDirectory(valueArg.flexCredentialDirectory)
+    || !Array.isArray(valueArg.projects)
+    || valueArg.projects.length > controllerProjectLimit
+    || !valueArg.projects.every(isFlexProjectRecord)
+  ) return false;
+  return new Set(valueArg.projects.map((project) => project.projectId)).size
+    === valueArg.projects.length;
+};
+
+export const isFlexServiceStatus = (valueArg: unknown): valueArg is IFlexServiceStatus => {
+  if (
+    !isFlexPlainObject(valueArg)
+    || !hasFlexExactKeys(valueArg, ['state', 'ready'], ['code', 'startedAt'])
+    || typeof valueArg.state !== 'string'
+    || !serviceStates.has(valueArg.state)
+    || typeof valueArg.ready !== 'boolean'
+    || (valueArg.code !== undefined
+      && (typeof valueArg.code !== 'string' || !serviceStatusCodes.has(valueArg.code)))
+    || (valueArg.startedAt !== undefined && !isIsoDate(valueArg.startedAt))
+  ) return false;
+  if (valueArg.state === 'ready') return valueArg.ready && valueArg.code === undefined;
+  return !valueArg.ready;
+};
+
+const isAccountSummary = (valueArg: unknown): valueArg is IFlexPublicAccountSummary =>
+  isFlexPlainObject(valueArg)
+  && hasFlexExactKeys(valueArg, ['providerId', 'authKind'], ['accountId', 'email', 'plan'])
+  && valueArg.providerId === 'openai'
+  && valueArg.authKind === 'chatgptOAuth'
+  && ['accountId', 'email', 'plan'].every((key) => (
+    valueArg[key] === undefined || isBoundedString(valueArg[key], 512)
+  ));
+
+export const isFlexPublicProviderConnection = (
+  valueArg: unknown,
+): valueArg is IFlexPublicProviderConnection => isFlexPlainObject(valueArg)
+  && hasFlexExactKeys(valueArg, ['loginId', 'providerId', 'status'], ['account'])
+  && isQualifiedId(valueArg.loginId)
+  && valueArg.providerId === 'openai'
+  && ['pending', 'active', 'deleting', 'reauthRequired'].includes(String(valueArg.status))
+  && (valueArg.account === undefined || isAccountSummary(valueArg.account));
+
+const isOpenCodeOAuthAuth = (valueArg: unknown): valueArg is IFlexOpenCodeOAuthAuth => (
+  isFlexPlainObject(valueArg)
+  && hasFlexExactKeys(valueArg, ['type', 'access', 'refresh', 'expires'], ['accountId'])
+  && valueArg.type === 'oauth'
+  && isBoundedString(valueArg.access, 16 * 1024)
+  && isBoundedString(valueArg.refresh, 16 * 1024)
+  && isNonNegativeInteger(valueArg.expires)
+  && (valueArg.accountId === undefined || isBoundedString(valueArg.accountId, 512))
+  && Buffer.byteLength(JSON.stringify(valueArg), 'utf8') <= 48 * 1024
+);
+
+const isModelChoice = (valueArg: unknown): valueArg is IFlexModelChoice =>
+  isFlexPlainObject(valueArg)
+  && hasFlexExactKeys(valueArg, ['providerConnectionId', 'modelId'], ['variant'])
+  && isQualifiedId(valueArg.providerConnectionId)
+  && isBoundedString(valueArg.modelId, 256)
+  && (valueArg.variant === undefined || isBoundedString(valueArg.variant, 128));
+
+const isModelIdentity = (valueArg: unknown): boolean => isFlexPlainObject(valueArg)
+  && hasFlexExactKeys(valueArg, ['provider', 'model'], ['displayName', 'variant'])
+  && isBoundedString(valueArg.provider, 256)
+  && isBoundedString(valueArg.model, 256)
+  && (valueArg.displayName === undefined || isBoundedString(valueArg.displayName, 512))
+  && (valueArg.variant === undefined || isBoundedString(valueArg.variant, 128));
+
+const isUsage = (valueArg: unknown): boolean => isFlexPlainObject(valueArg)
+  && hasFlexExactKeys(valueArg, [
+    'inputTokens', 'outputTokens', 'totalTokens', 'cacheReadTokens', 'cacheWriteTokens',
+  ])
+  && Object.values(valueArg).every(isNonNegativeInteger);
+
+const isMessagePart = (valueArg: unknown): boolean => {
+  if (!isFlexPlainObject(valueArg) || !isIdentifier(valueArg.partId)) return false;
+  switch (valueArg.type) {
+    case 'text':
+      return hasFlexExactKeys(valueArg, ['partId', 'type', 'text'])
+        && isBoundedString(valueArg.text, 96 * 1024, true);
+    case 'reasoning':
+      return hasFlexExactKeys(valueArg, ['partId', 'type', 'text', 'status'])
+        && isBoundedString(valueArg.text, 96 * 1024, true)
+        && ['running', 'completed', 'cancelled'].includes(String(valueArg.status));
+    case 'tool':
+      return hasFlexExactKeys(
+        valueArg,
+        ['partId', 'type', 'toolCallId', 'toolName', 'status', 'input'],
+        ['output', 'error', 'childSessionId', 'model'],
+      )
+        && isIdentifier(valueArg.toolCallId)
+        && isBoundedString(valueArg.toolName, 512)
+        && ['running', 'completed', 'failed', 'cancelled'].includes(String(valueArg.status))
+        && isJsonValue(valueArg.input)
+        && (valueArg.output === undefined || isJsonValue(valueArg.output))
+        && (valueArg.error === undefined || isBoundedString(valueArg.error, 2048))
+        && (valueArg.childSessionId === undefined || isIdentifier(valueArg.childSessionId))
+        && (valueArg.model === undefined || (
+          valueArg.childSessionId !== undefined && isModelIdentity(valueArg.model)
+        ));
+    case 'attachment':
+      return hasFlexExactKeys(
+        valueArg,
+        ['partId', 'type', 'attachmentType', 'source'],
+        ['sizeBytes', 'mediaType', 'name'],
+      )
+        && ['image', 'file'].includes(String(valueArg.attachmentType))
+        && ['inline-base64', 'data-url', 'remote-url'].includes(String(valueArg.source))
+        && (valueArg.sizeBytes === undefined || isNonNegativeInteger(valueArg.sizeBytes))
+        && (valueArg.mediaType === undefined || isBoundedString(valueArg.mediaType, 512))
+        && (valueArg.name === undefined || isBoundedString(valueArg.name, 1024));
+    default:
+      return false;
+  }
+};
+
+export const isFlexPublicMessage = (valueArg: unknown): valueArg is TFlexMessage =>
+  isFlexPlainObject(valueArg)
+  && hasFlexExactKeys(
+    valueArg,
+    ['messageId', 'sessionId', 'runId', 'role', 'status', 'createdAt', 'parts'],
+    ['completedAt', 'model', 'usage', 'error'],
+  )
+  && isIdentifier(valueArg.messageId)
+  && isIdentifier(valueArg.sessionId)
+  && isIdentifier(valueArg.runId)
+  && ['user', 'assistant'].includes(String(valueArg.role))
+  && ['streaming', 'completed', 'failed', 'cancelled'].includes(String(valueArg.status))
+  && isIsoDate(valueArg.createdAt)
+  && (valueArg.completedAt === undefined || isIsoDate(valueArg.completedAt))
+  && Array.isArray(valueArg.parts)
+  && valueArg.parts.length <= 2000
+  && valueArg.parts.every(isMessagePart)
+  && (valueArg.model === undefined || isModelIdentity(valueArg.model))
+  && (valueArg.usage === undefined || isUsage(valueArg.usage))
+  && (valueArg.error === undefined || isBoundedString(valueArg.error, 2048));
+
+export const isFlexPublicSession = (valueArg: unknown): valueArg is TFlexSession => {
+  if (
+    !isFlexPlainObject(valueArg)
+    || !hasFlexExactKeys(
+      valueArg,
+      ['scopeId', 'sessionId', 'createdAt', 'updatedAt', 'status', 'activity'],
+      [
+        'sessionGenerationId', 'sessionGenerationSequence',
+        'title', 'archivedAt', 'parentSessionId', 'parentRunId',
+        'parentToolCallId', 'agent', 'depth',
+      ],
+    )
+    || !isIdentifier(valueArg.scopeId)
+    || !isIdentifier(valueArg.sessionId)
+    || !isIsoDate(valueArg.createdAt)
+    || !isIsoDate(valueArg.updatedAt)
+    || (valueArg.title !== undefined || Object.hasOwn(valueArg, 'title'))
+      && !isBoundedString(valueArg.title, 4096, true)
+    || (valueArg.archivedAt !== undefined && !isIsoDate(valueArg.archivedAt))
+    || !['idle', 'scheduled', 'running', 'waiting_permission', 'failed', 'cancelled']
+      .includes(String(valueArg.status))
+    || !isFlexPlainObject(valueArg.activity)
+    || !hasFlexExactKeys(valueArg.activity, ['status'], [
+      'runId', 'startedAt', 'completedAt', 'error',
+    ])
+    || !['idle', 'scheduled', 'running', 'waiting_permission', 'failed', 'cancelled']
+      .includes(String(valueArg.activity.status))
+  ) return false;
+  const hasGenerationId = valueArg.sessionGenerationId !== undefined;
+  const hasGenerationSequence = valueArg.sessionGenerationSequence !== undefined;
+  if (
+    hasGenerationId !== hasGenerationSequence
+    || (hasGenerationId && !isFlexSessionGeneration(valueArg))
+  ) return false;
+  const relationship = [
+    valueArg.parentSessionId,
+    valueArg.parentRunId,
+    valueArg.parentToolCallId,
+    valueArg.agent,
+  ];
+  const relationshipCount = relationship.filter((entry) => entry !== undefined).length;
+  return (valueArg.activity.runId === undefined || isIdentifier(valueArg.activity.runId))
+    && (valueArg.activity.startedAt === undefined || isIsoDate(valueArg.activity.startedAt))
+    && (valueArg.activity.completedAt === undefined || isIsoDate(valueArg.activity.completedAt))
+    && (valueArg.activity.error === undefined || isBoundedString(valueArg.activity.error, 2048))
+    && (relationshipCount === 0 || relationshipCount === relationship.length)
+    && (valueArg.parentSessionId === undefined || isIdentifier(valueArg.parentSessionId))
+    && (valueArg.parentRunId === undefined || isIdentifier(valueArg.parentRunId))
+    && (valueArg.parentToolCallId === undefined || isIdentifier(valueArg.parentToolCallId))
+    && (valueArg.agent === undefined || isBoundedString(valueArg.agent, 128))
+    && (
+      relationshipCount === 0
+        ? valueArg.depth === undefined || valueArg.depth === 0
+        : Number.isSafeInteger(valueArg.depth)
+          && Number(valueArg.depth) >= 1
+          && Number(valueArg.depth) <= 8
+    );
+};
+
+const isPromptQueueEntry = (valueArg: unknown): valueArg is TFlexPromptQueueEntry => (
+  isFlexPlainObject(valueArg)
+  && hasFlexExactKeys(
+    valueArg,
+    ['queueId', 'queueSequence', 'scopeId', 'sessionId', 'status', 'queuedAt'],
+    ['runId', 'scheduleKey', 'startedAt', 'finishedAt', 'error'],
+  )
+  && isIdentifier(valueArg.queueId)
+  && isNonNegativeInteger(valueArg.queueSequence)
+  && valueArg.queueSequence >= 1
+  && isIdentifier(valueArg.scopeId)
+  && isIdentifier(valueArg.sessionId)
+  && ['queued', 'starting', 'scheduled', 'running', 'completed', 'failed', 'cancelled']
+    .includes(String(valueArg.status))
+  && isIsoDate(valueArg.queuedAt)
+  && (valueArg.runId === undefined || isIdentifier(valueArg.runId))
+  && (valueArg.scheduleKey === undefined || isIdentifier(valueArg.scheduleKey))
+  && (valueArg.startedAt === undefined || isIsoDate(valueArg.startedAt))
+  && (valueArg.finishedAt === undefined || isIsoDate(valueArg.finishedAt))
+  && (valueArg.error === undefined || (
+    isFlexPlainObject(valueArg.error)
+    && hasFlexExactKeys(valueArg.error, ['name', 'message'], ['code'])
+    && isBoundedString(valueArg.error.name, 128)
+    && isBoundedString(valueArg.error.message, 2048)
+    && (valueArg.error.code === undefined || isBoundedString(valueArg.error.code, 128))
+  ))
+);
+
+const isPermissionRequest = (valueArg: unknown): valueArg is TFlexPermissionRequest =>
+  isFlexPlainObject(valueArg)
+  && hasFlexExactKeys(
+    valueArg,
+    ['permissionId', 'scopeId', 'sessionId', 'runId', 'createdAt', 'kind', 'description'],
+    ['toolCallId', 'rememberKey', 'metadata'],
+  )
+  && isIdentifier(valueArg.permissionId)
+  && isIdentifier(valueArg.scopeId)
+  && isIdentifier(valueArg.sessionId)
+  && isIdentifier(valueArg.runId)
+  && isIsoDate(valueArg.createdAt)
+  && isBoundedString(valueArg.kind, 128)
+  && isBoundedString(valueArg.description, 2048)
+  && (valueArg.toolCallId === undefined || isIdentifier(valueArg.toolCallId))
+  && (valueArg.rememberKey === undefined || isBoundedString(valueArg.rememberKey, 512))
+  && (valueArg.metadata === undefined || isJsonValue(valueArg.metadata));
+
+const isPrompt = (valueArg: unknown): valueArg is TFlexPrompt => {
+  if (isBoundedString(valueArg, 768 * 1024, true)) return true;
+  if (!Array.isArray(valueArg) || valueArg.length < 1 || valueArg.length > 128) return false;
+  return valueArg.every((part) => {
+    if (!isFlexPlainObject(part)) return false;
+    if (part.type === 'text') {
+      return hasFlexExactKeys(part, ['type', 'text'])
+        && isBoundedString(part.text, 768 * 1024, true);
+    }
+    if (part.type === 'image') {
+      return hasFlexExactKeys(part, ['type', 'data'], ['mediaType', 'name'])
+        && isBoundedString(part.data, 768 * 1024)
+        && (part.mediaType === undefined || isBoundedString(part.mediaType, 512))
+        && (part.name === undefined || isBoundedString(part.name, 1024));
+    }
+    if (part.type === 'file') {
+      return hasFlexExactKeys(part, ['type', 'data', 'mediaType'], ['name'])
+        && isBoundedString(part.data, 768 * 1024)
+        && isBoundedString(part.mediaType, 512)
+        && (part.name === undefined || isBoundedString(part.name, 1024));
+    }
+    return false;
+  });
+};
+
+const isPromptOptions = (valueArg: unknown): valueArg is TFlexPromptOptions =>
+  isFlexPlainObject(valueArg)
+  && hasFlexExactKeys(valueArg, [], ['modelHint', 'system', 'maxSteps'])
+  && (valueArg.modelHint === undefined || isBoundedString(valueArg.modelHint, 512))
+  && (valueArg.system === undefined || isBoundedString(valueArg.system, 128 * 1024, true))
+  && (valueArg.maxSteps === undefined
+    || (Number.isSafeInteger(valueArg.maxSteps) && Number(valueArg.maxSteps) >= 1
+      && Number(valueArg.maxSteps) <= 1000));
+
+const isCreateSessionOptions = (valueArg: unknown): valueArg is TFlexCreateSessionOptions =>
+  isFlexPlainObject(valueArg)
+  && hasFlexExactKeys(valueArg, [], ['sessionId', 'title'])
+  && (valueArg.sessionId === undefined || isIdentifier(valueArg.sessionId))
+  && (valueArg.title === undefined || isBoundedString(valueArg.title, 4096, true));
+
+const isUpdateSessionOptions = (valueArg: unknown): valueArg is TFlexUpdateSessionOptions =>
+  isFlexPlainObject(valueArg)
+  && hasFlexExactKeys(valueArg, [], ['title', 'archived'])
+  && (valueArg.title === undefined || valueArg.title === null
+    || isBoundedString(valueArg.title, 4096, true))
+  && (valueArg.archived === undefined || typeof valueArg.archived === 'boolean');
+
+const isScopeAndSession = (valueArg: Record<string, unknown>): boolean =>
+  isIdentifier(valueArg.scopeId) && isIdentifier(valueArg.sessionId);
+
+const isAffectedWorkspace = (valueArg: unknown): boolean => isFlexPlainObject(valueArg)
+  && hasFlexExactKeys(valueArg, ['id', 'label'])
+  && isBoundedString(valueArg.id, 512)
+  && valueArg.id.trim().length > 0
+  && isBoundedString(valueArg.label, 2048)
+  && valueArg.label.trim().length > 0;
+
+const isReversionOutcome = (
+  valueArg: unknown,
+): valueArg is TFlexTurnReversionFinalizedOutcome => {
+  if (!isFlexPlainObject(valueArg) || !isJsonValue(valueArg.reference)) return false;
+  if (valueArg.disposition === 'no-change') {
+    return hasFlexExactKeys(valueArg, ['disposition', 'reference'], ['affectedWorkspaces'])
+      && (valueArg.affectedWorkspaces === undefined
+        || (Array.isArray(valueArg.affectedWorkspaces) && valueArg.affectedWorkspaces.length === 0));
+  }
+  if (valueArg.disposition === 'revertible') {
+    return hasFlexExactKeys(valueArg, ['disposition', 'reference', 'affectedWorkspaces'])
+      && Array.isArray(valueArg.affectedWorkspaces)
+      && valueArg.affectedWorkspaces.length >= 1
+      && valueArg.affectedWorkspaces.length <= 64
+      && valueArg.affectedWorkspaces.every(isAffectedWorkspace)
+      && new Set(valueArg.affectedWorkspaces.map((entry) => (
+        entry as { id: string }
+      ).id)).size === valueArg.affectedWorkspaces.length;
+  }
+  return valueArg.disposition === 'nonrevertible'
+    && hasFlexExactKeys(
+      valueArg,
+      ['disposition', 'reference', 'reasonCode'],
+      ['affectedWorkspaces'],
+    )
+    && isBoundedString(valueArg.reasonCode, 128)
+    && /^[A-Za-z0-9][A-Za-z0-9._-]*$/u.test(valueArg.reasonCode)
+    && (valueArg.affectedWorkspaces === undefined || (
+      Array.isArray(valueArg.affectedWorkspaces)
+      && valueArg.affectedWorkspaces.length <= 64
+      && valueArg.affectedWorkspaces.every(isAffectedWorkspace)
+    ));
+};
+
+const isSlashDescriptor = (valueArg: unknown): valueArg is TFlexSlashCommandDescriptor => (
+  isFlexPlainObject(valueArg)
+  && hasFlexExactKeys(
+    valueArg,
+    ['name', 'description', 'kind', 'hints', 'available', 'workspaceReversion'],
+    ['unavailableReason'],
+  )
+  && typeof valueArg.name === 'string'
+  && /^[a-z][a-z0-9-]{0,63}$/u.test(valueArg.name)
+  && isBoundedString(valueArg.description, 2048, true)
+  && ['builtin', 'template', 'handler'].includes(String(valueArg.kind))
+  && Array.isArray(valueArg.hints)
+  && valueArg.hints.length <= 64
+  && valueArg.hints.every((hint) => isBoundedString(hint, 128))
+  && typeof valueArg.available === 'boolean'
+  && (valueArg.unavailableReason === undefined
+    || isBoundedString(valueArg.unavailableReason, 2048))
+  && ['supported', 'unsupported', 'not-applicable'].includes(
+    String(valueArg.workspaceReversion),
+  )
+);
+
+const isSlashInvocation = (valueArg: Record<string, unknown>): boolean => (
+  isBoundedString(valueArg.input, 768 * 1024)
+  && typeof valueArg.name === 'string'
+  && /^[a-z][a-z0-9-]{0,63}$/u.test(valueArg.name)
+  && isBoundedString(valueArg.rawArguments, 768 * 1024, true)
+  && Array.isArray(valueArg.arguments)
+  && valueArg.arguments.length <= 4096
+  && valueArg.arguments.every((entry) => isBoundedString(entry, 768 * 1024, true))
+);
+
+const isSlashExecutionResult = (valueArg: unknown): valueArg is TFlexSlashExecutionResult => {
+  if (!isFlexPlainObject(valueArg) || typeof valueArg.type !== 'string') return false;
+  if (valueArg.type === 'not-command') return hasFlexExactKeys(valueArg, ['type']);
+  if (valueArg.type === 'malformed') {
+    return hasFlexExactKeys(valueArg, ['type', 'reason'])
+      && isBoundedString(valueArg.reason, 2048);
+  }
+  if (valueArg.type === 'unknown') {
+    return hasFlexExactKeys(valueArg, ['type', 'input', 'name', 'rawArguments', 'arguments'])
+      && isSlashInvocation(valueArg);
+  }
+  if (valueArg.type === 'operation') {
+    return hasFlexExactKeys(valueArg, ['type', 'name'])
+      && typeof valueArg.name === 'string'
+      && /^[a-z][a-z0-9-]{0,63}$/u.test(valueArg.name);
+  }
+  if (valueArg.type === 'handler-result') {
+    return hasFlexExactKeys(valueArg, ['type', 'name', 'result'])
+      && typeof valueArg.name === 'string'
+      && /^[a-z][a-z0-9-]{0,63}$/u.test(valueArg.name)
+      && isJsonValue(valueArg.result);
+  }
+  return valueArg.type === 'prompt-admission'
+    && hasFlexExactKeys(valueArg, ['type', 'name', 'admission'])
+    && typeof valueArg.name === 'string'
+    && /^[a-z][a-z0-9-]{0,63}$/u.test(valueArg.name)
+    && isFlexPlainObject(valueArg.admission)
+    && hasFlexExactKeys(valueArg.admission, ['queueId', 'runId'])
+    && isIdentifier(valueArg.admission.queueId)
+    && isIdentifier(valueArg.admission.runId);
+};
+
+const isSessionReversionInfo = (valueArg: unknown): valueArg is TFlexSessionReversionInfo => (
+  isFlexPlainObject(valueArg)
+  && hasFlexExactKeys(valueArg, ['undoAvailable', 'redoAvailable', 'groups'])
+  && typeof valueArg.undoAvailable === 'boolean'
+  && typeof valueArg.redoAvailable === 'boolean'
+  && Array.isArray(valueArg.groups)
+  && valueArg.groups.length <= 3000
+  && valueArg.groups.every((entry) => isFlexPlainObject(entry)
+    && hasFlexExactKeys(entry, [
+      'runId', 'kind', 'visibility', 'affectedWorkspaces', 'affectedWorkspacesTruncated',
+    ])
+    && isIdentifier(entry.runId)
+    && ['candidate', 'barrier', 'no-change'].includes(String(entry.kind))
+    && ['visible', 'hidden'].includes(String(entry.visibility))
+    && Array.isArray(entry.affectedWorkspaces)
+    && entry.affectedWorkspaces.length <= 64
+    && entry.affectedWorkspaces.every(isAffectedWorkspace)
+    && typeof entry.affectedWorkspacesTruncated === 'boolean')
+);
+
+export const isFlexRequestPayload = <TMethod extends TFlexRequestMethod>(
+  methodArg: TMethod,
+  valueArg: unknown,
+): valueArg is TFlexRequest<TMethod> => {
+  if (!isFlexPlainObject(valueArg)) return false;
+  switch (methodArg) {
+    case 'service.status':
+    case 'provider.list':
+    case 'provider.connection.list':
+      return hasFlexExactKeys(valueArg, []);
+    case 'project.replaceAll':
+      return hasFlexExactKeys(valueArg, ['projects'])
+        && Array.isArray(valueArg.projects)
+        && valueArg.projects.length <= controllerProjectLimit
+        && valueArg.projects.every(isFlexProjectRecord)
+        && new Set(valueArg.projects.map((project) => project.projectId)).size
+          === valueArg.projects.length;
+    case 'project.register':
+    case 'project.remove':
+      return hasFlexExactKeys(valueArg, ['project'])
+        && isFlexIdentityBoundProjectRecord(valueArg.project);
+    case 'intelligence.start':
+      return hasFlexExactKeys(valueArg, [
+        'scopeId', 'sourceSessionId', 'question', 'scratchpad', 'model', 'capabilityToken',
+      ])
+        && isIdentifier(valueArg.scopeId)
+        && isFlexIntelligenceSessionId(valueArg.sourceSessionId)
+        && isBoundedString(valueArg.question, 32 * 1024)
+        && valueArg.question.length <= 8_192
+        && String(valueArg.question).trim().length > 0
+        && isBoundedString(valueArg.scratchpad, 128 * 1024, true)
+        && valueArg.scratchpad.length <= 32_768
+        && isModelChoice(valueArg.model)
+        && valueArg.model.modelId === 'gpt-5.6-luna'
+        && valueArg.model.variant === undefined
+        && isIntelligenceCapabilityToken(valueArg.capabilityToken);
+    case 'intelligence.get':
+      return hasFlexExactKeys(valueArg, ['scopeId', 'jobId', 'capabilityToken'])
+        && isIdentifier(valueArg.scopeId)
+        && isQualifiedId(valueArg.jobId)
+        && isIntelligenceCapabilityToken(valueArg.capabilityToken);
+    case 'intelligence.cancel':
+      return hasFlexExactKeys(valueArg, ['scopeId', 'capabilityToken'])
+        && isIdentifier(valueArg.scopeId)
+        && isIntelligenceCapabilityToken(valueArg.capabilityToken);
+    case 'session.list':
+      return hasFlexExactKeys(valueArg, ['scopeId'], ['offset', 'limit'])
+        && isIdentifier(valueArg.scopeId)
+        && (valueArg.offset === undefined || isNonNegativeInteger(valueArg.offset))
+        && (valueArg.limit === undefined
+          || (Number.isSafeInteger(valueArg.limit) && Number(valueArg.limit) >= 1
+            && Number(valueArg.limit) <= 50));
+    case 'session.create':
+      return hasFlexExactKeys(valueArg, ['scopeId'], ['options'])
+        && isIdentifier(valueArg.scopeId)
+        && (valueArg.options === undefined || isCreateSessionOptions(valueArg.options));
+    case 'session.get':
+    case 'session.delete':
+    case 'session.reversion.info':
+    case 'slash.list':
+    case 'prompt.list':
+      return hasFlexExactKeys(valueArg, ['scopeId', 'sessionId'])
+        && isScopeAndSession(valueArg);
+    case 'session.compact':
+      return hasFlexExactKeys(valueArg, ['scopeId', 'sessionId'], ['model'])
+        && isScopeAndSession(valueArg)
+        && (valueArg.model === undefined || isModelChoice(valueArg.model));
+    case 'slash.execute':
+      return hasFlexExactKeys(valueArg, ['scopeId', 'sessionId', 'input'], ['model'])
+        && isScopeAndSession(valueArg)
+        && isBoundedString(valueArg.input, 768 * 1024)
+        && (valueArg.model === undefined || isModelChoice(valueArg.model));
+    case 'session.update':
+      return hasFlexExactKeys(valueArg, ['scopeId', 'sessionId', 'options'])
+        && isScopeAndSession(valueArg)
+        && isUpdateSessionOptions(valueArg.options);
+    case 'message.page':
+      return hasFlexExactKeys(valueArg, ['scopeId', 'sessionId'], ['limit', 'before'])
+        && isScopeAndSession(valueArg)
+        && (valueArg.limit === undefined
+          || (Number.isSafeInteger(valueArg.limit) && Number(valueArg.limit) >= 1
+            && Number(valueArg.limit) <= 50))
+        && (valueArg.before === undefined || isBoundedString(valueArg.before, 4096));
+    case 'message.get':
+      return hasFlexExactKeys(valueArg, ['scopeId', 'sessionId', 'messageId'])
+        && isScopeAndSession(valueArg) && isIdentifier(valueArg.messageId);
+    case 'prompt.start':
+      return hasFlexExactKeys(
+        valueArg,
+        ['scopeId', 'sessionId', 'prompt'],
+        ['options', 'model', 'upload'],
+      )
+        && isScopeAndSession(valueArg)
+        && isPrompt(valueArg.prompt)
+        && (valueArg.options === undefined || isPromptOptions(valueArg.options))
+        && (valueArg.model === undefined || isModelChoice(valueArg.model))
+        && (valueArg.upload === undefined || (
+          isFlexPlainObject(valueArg.upload)
+          && hasFlexExactKeys(valueArg.upload, ['operationId', 'directory'])
+          && isIdentifier(valueArg.upload.operationId)
+          && isBoundedString(valueArg.upload.directory, 4096)
+          && plugins.path.isAbsolute(valueArg.upload.directory)
+        ));
+    case 'prompt.get':
+    case 'prompt.cancel':
+      return hasFlexExactKeys(valueArg, ['scopeId', 'sessionId', 'queueId'])
+        && isScopeAndSession(valueArg) && isIdentifier(valueArg.queueId);
+    case 'prompt.acknowledge':
+      return hasFlexExactKeys(valueArg, ['scopeId', 'sessionId', 'queueId', 'runId'])
+        && isScopeAndSession(valueArg)
+        && isIdentifier(valueArg.queueId)
+        && isIdentifier(valueArg.runId);
+    case 'permission.list':
+      return hasFlexExactKeys(valueArg, ['scopeId'], ['sessionId', 'familyRootSessionId'])
+        && isIdentifier(valueArg.scopeId)
+        && (valueArg.sessionId === undefined || isIdentifier(valueArg.sessionId))
+        && (valueArg.familyRootSessionId === undefined
+          || isIdentifier(valueArg.familyRootSessionId))
+        && !(valueArg.sessionId !== undefined && valueArg.familyRootSessionId !== undefined);
+    case 'permission.respond':
+      return hasFlexExactKeys(
+        valueArg,
+        ['scopeId', 'sessionId', 'permissionId', 'decision'],
+      )
+        && isScopeAndSession(valueArg)
+        && isIdentifier(valueArg.permissionId)
+        && ['once', 'always', 'reject'].includes(String(valueArg.decision));
+    case 'provider.login.begin':
+      return hasFlexExactKeys(valueArg, ['providerId']) && valueArg.providerId === 'openai';
+    case 'provider.login.status':
+    case 'provider.login.cancel':
+      return hasFlexExactKeys(valueArg, ['loginId']) && isQualifiedId(valueArg.loginId);
+    case 'provider.connection.logout.prepare':
+    case 'provider.connection.logout':
+    case 'provider.connection.opencode-auth.get':
+    case 'provider.connection.ratelimits.get':
+    case 'provider.models.refresh':
+      return hasFlexExactKeys(valueArg, ['providerConnectionId'])
+        && isQualifiedId(valueArg.providerConnectionId);
+    case 'model.choice.get':
+      return hasFlexExactKeys(valueArg, ['scopeId']) && isIdentifier(valueArg.scopeId);
+    case 'model.choice.set':
+      return hasFlexExactKeys(valueArg, ['scopeId', 'choice'])
+        && isIdentifier(valueArg.scopeId) && isModelChoice(valueArg.choice);
+    case 'model.choice.validate':
+      return hasFlexExactKeys(valueArg, ['choice']) && isModelChoice(valueArg.choice);
+    default:
+      return false;
+  }
+};
+
+export const isFlexHostRequestPayload = <TMethod extends TFlexHostRequestMethod>(
+  methodArg: TMethod,
+  valueArg: unknown,
+): valueArg is TFlexHostRequest<TMethod> => {
+  if (!isFlexPlainObject(valueArg)) return false;
+  const reversionBase = (optionalKeysArg: readonly string[] = []) => (
+    hasFlexExactKeys(
+      valueArg,
+      ['scopeId', 'storageKey', 'sessionId', 'runId', 'captureId'],
+      optionalKeysArg,
+    )
+    && isIdentifier(valueArg.scopeId)
+    && isIdentifier(valueArg.storageKey)
+    && isIdentifier(valueArg.sessionId)
+    && isIdentifier(valueArg.runId)
+    && isIdentifier(valueArg.captureId)
+  );
+  if (
+    methodArg === 'reversion.prepare'
+    || methodArg === 'reversion.inspect-capture'
+    || methodArg === 'reversion.finalize'
+  ) return reversionBase();
+  if (methodArg === 'reversion.inspect-apply' || methodArg === 'reversion.apply') {
+    return reversionBase(['reference', 'operationId', 'direction'])
+      && Object.hasOwn(valueArg, 'reference')
+      && isJsonValue(valueArg.reference)
+      && Buffer.byteLength(JSON.stringify(valueArg.reference), 'utf8') <= 256 * 1024
+      && isIdentifier(valueArg.operationId)
+      && (valueArg.direction === 'undo' || valueArg.direction === 'redo');
+  }
+  if (methodArg === 'reversion.release') {
+    return reversionBase(['reference'])
+      && Object.hasOwn(valueArg, 'reference')
+      && isJsonValue(valueArg.reference)
+      && Buffer.byteLength(JSON.stringify(valueArg.reference), 'utf8') <= 256 * 1024;
+  }
+  if (methodArg === 'git.worktree.create' || methodArg === 'git.worktree.list') {
+    return hasFlexExactKeys(valueArg, ['scopeId', 'sessionId'])
+      && isIdentifier(valueArg.scopeId)
+      && isIdentifier(valueArg.sessionId);
+  }
+  if (methodArg === 'git.worktree.remove') {
+    const compensating = Object.hasOwn(valueArg, 'compensate');
+    return hasFlexExactKeys(
+      valueArg,
+      ['scopeId', 'sessionId', 'worktreeId', ...(compensating ? ['compensate'] : [])],
+    )
+      && isIdentifier(valueArg.scopeId)
+      && isIdentifier(valueArg.sessionId)
+      && isIdentifier(valueArg.worktreeId)
+      && (!compensating || valueArg.compensate === true);
+  }
+  if (methodArg === 'crossharness.chats.list') {
+    return hasFlexExactKeys(valueArg, ['capabilityToken', 'limit'])
+      && isIntelligenceCapabilityToken(valueArg.capabilityToken)
+      && Number.isSafeInteger(valueArg.limit)
+      && Number(valueArg.limit) >= 1
+      && Number(valueArg.limit) <= 50;
+  }
+  if (methodArg === 'crossharness.chat.read') {
+    return hasFlexExactKeys(
+      valueArg,
+      ['capabilityToken', 'sessionId', 'limit', 'maxChars'],
+    )
+      && isIntelligenceCapabilityToken(valueArg.capabilityToken)
+      && isFlexIntelligenceSessionId(valueArg.sessionId)
+      && Number.isSafeInteger(valueArg.limit)
+      && Number(valueArg.limit) >= 1
+      && Number(valueArg.limit) <= 50
+      && Number.isSafeInteger(valueArg.maxChars)
+      && Number(valueArg.maxChars) >= 128
+      && Number(valueArg.maxChars) <= 4096;
+  }
+  if (methodArg === 'project-management.load') {
+    return hasFlexExactKeys(valueArg, [
+      'storageKey',
+      'sessionId',
+      'sessionGenerationId',
+      'sessionGenerationSequence',
+    ])
+      && isIdentifier(valueArg.storageKey)
+      && isIdentifier(valueArg.sessionId)
+      && isFlexSessionGeneration(valueArg);
+  }
+  if (methodArg === 'project-management.save') {
+    return hasFlexExactKeys(valueArg, [
+      'storageKey',
+      'sessionId',
+      'snapshot',
+      'expectedRevision',
+      'writeContext',
+    ])
+      && isIdentifier(valueArg.storageKey)
+      && isIdentifier(valueArg.sessionId)
+      && isFlexProjectManagementSnapshot(valueArg.snapshot)
+      && isNonNegativeInteger(valueArg.expectedRevision)
+      && valueArg.snapshot.revision === Number(valueArg.expectedRevision) + 1
+      && isFlexProjectManagementWriteContext(valueArg.writeContext);
+  }
+  if (methodArg === 'project-management.tombstone') {
+    return hasFlexExactKeys(valueArg, [
+      'storageKey',
+      'sessionId',
+      'tombstone',
+      'expectedRevision',
+    ])
+      && isIdentifier(valueArg.storageKey)
+      && isIdentifier(valueArg.sessionId)
+      && isFlexProjectManagementTombstone(valueArg.tombstone)
+      && isNonNegativeInteger(valueArg.expectedRevision)
+      && valueArg.tombstone.revision === Number(valueArg.expectedRevision) + 1;
+  }
+  if (methodArg === 'project-management.purge') {
+    return hasFlexExactKeys(valueArg, ['storageKey']) && isIdentifier(valueArg.storageKey);
+  }
+  if (methodArg === 'browser.channel.close') {
+    return hasFlexExactKeys(valueArg, ['channelId']) && isChannelId(valueArg.channelId);
+  }
+  const common = hasFlexExactKeys(
+    valueArg,
+    methodArg === 'browser.resources.resolve'
+      ? ['scopeId', 'sessionId', 'runId']
+      : ['scopeId', 'sessionId', 'runId', 'resourceId', 'attachmentRevision', 'channelId'],
+  )
+    && isBoundedString(valueArg.scopeId, 128)
+    && identifierPattern.test(String(valueArg.scopeId))
+    && isBoundedString(valueArg.sessionId, 128)
+    && identifierPattern.test(String(valueArg.sessionId))
+    && isBoundedString(valueArg.runId, 512)
+    && identifierPattern.test(String(valueArg.runId));
+  if (!common || methodArg === 'browser.resources.resolve') return common;
+  return isBoundedString(valueArg.resourceId, 256)
+    && Buffer.byteLength(String(valueArg.resourceId), 'utf8') >= 16
+    && identifierPattern.test(String(valueArg.resourceId))
+    && isNonNegativeInteger(valueArg.attachmentRevision)
+    && isChannelId(valueArg.channelId);
+};
+
+const isGitWorktreeDescriptor = (
+  valueArg: unknown,
+): valueArg is IFlexGitWorktreeDescriptor => isFlexPlainObject(valueArg)
+  && hasFlexExactKeys(valueArg, [
+    'worktreeId', 'projectId', 'sessionId', 'path', 'repositoryId', 'createdAt',
+  ])
+  && isIdentifier(valueArg.worktreeId)
+  && typeof valueArg.projectId === 'string'
+  && projectIdPattern.test(valueArg.projectId)
+  && isIdentifier(valueArg.sessionId)
+  && isBoundedString(valueArg.path, 4096)
+  && !valueArg.path.includes('\0')
+  && plugins.path.isAbsolute(valueArg.path)
+  && plugins.path.normalize(valueArg.path) === valueArg.path
+  && isIdentifier(valueArg.repositoryId)
+  && isIsoDate(valueArg.createdAt);
+
+const isFlexBrowserResourceDescriptor = (
+  valueArg: unknown,
+): valueArg is IFlexBrowserResourceDescriptor => isFlexPlainObject(valueArg)
+  && hasFlexExactKeys(valueArg, ['resourceId', 'attachmentRevision'])
+  && isBoundedString(valueArg.resourceId, 256)
+  && Buffer.byteLength(valueArg.resourceId, 'utf8') >= 16
+  && identifierPattern.test(valueArg.resourceId)
+  && isNonNegativeInteger(valueArg.attachmentRevision);
+
+const isFlexBrowserChannelBinding = (
+  valueArg: unknown,
+): valueArg is IFlexBrowserChannelBinding => isFlexPlainObject(valueArg)
+  && hasFlexExactKeys(valueArg, [
+    'projectId',
+    'browserResourceId',
+    'attachmentAuthorityId',
+    'attachmentRevision',
+    'actorId',
+    'peerId',
+    'role',
+    'source',
+    'scopeId',
+    'channelId',
+    'runId',
+    'sessionId',
+  ])
+  && isBoundedString(valueArg.projectId, 128)
+  && isBoundedString(valueArg.browserResourceId, 256)
+  && Buffer.byteLength(valueArg.browserResourceId, 'utf8') >= 16
+  && isBoundedString(valueArg.attachmentAuthorityId, 256)
+  && isNonNegativeInteger(valueArg.attachmentRevision)
+  && isBoundedString(valueArg.actorId, 256)
+  && isBoundedString(valueArg.peerId, 256)
+  && valueArg.role === 'agent'
+  && valueArg.source === 'flex'
+  && isBoundedString(valueArg.scopeId, 128)
+  && isChannelId(valueArg.channelId)
+  && isBoundedString(valueArg.runId, 512)
+  && identifierPattern.test(valueArg.runId)
+  && isFlexPlainObject(valueArg.sessionId)
+  && hasFlexExactKeys(valueArg.sessionId, ['harnessId', 'nativeId'])
+  && valueArg.sessionId.harnessId === 'flex'
+  && isBoundedString(valueArg.sessionId.nativeId, 128);
+
+export const isFlexHostResponseResult = <TMethod extends TFlexHostRequestMethod>(
+  methodArg: TMethod,
+  valueArg: unknown,
+): valueArg is TFlexHostResponse<TMethod> => {
+  if (!isFlexPlainObject(valueArg)) return false;
+  if (methodArg === 'reversion.prepare') {
+    return hasFlexExactKeys(valueArg, ['prepared']) && valueArg.prepared === true;
+  }
+  if (methodArg === 'reversion.inspect-capture') {
+    if (valueArg.status === 'finalized') {
+      return hasFlexExactKeys(valueArg, ['status', 'outcome'])
+        && isReversionOutcome(valueArg.outcome);
+    }
+    return hasFlexExactKeys(valueArg, ['status'])
+      && ['missing', 'prepared', 'unknown'].includes(String(valueArg.status));
+  }
+  if (methodArg === 'reversion.finalize') return isReversionOutcome(valueArg);
+  if (methodArg === 'reversion.inspect-apply') {
+    return hasFlexExactKeys(valueArg, ['status'])
+      && ['not-applied', 'applied', 'unknown'].includes(String(valueArg.status));
+  }
+  if (methodArg === 'reversion.apply') {
+    return hasFlexExactKeys(valueArg, ['applied']) && valueArg.applied === true;
+  }
+  if (methodArg === 'reversion.release') {
+    return hasFlexExactKeys(valueArg, ['released']) && valueArg.released === true;
+  }
+  if (methodArg === 'git.worktree.create') {
+    return hasFlexExactKeys(valueArg, ['worktree'])
+      && isGitWorktreeDescriptor(valueArg.worktree);
+  }
+  if (methodArg === 'git.worktree.list') {
+    return hasFlexExactKeys(valueArg, ['worktrees'])
+      && Array.isArray(valueArg.worktrees)
+      && valueArg.worktrees.length <= 128
+      && valueArg.worktrees.every(isGitWorktreeDescriptor);
+  }
+  if (methodArg === 'git.worktree.remove') {
+    return hasFlexExactKeys(valueArg, ['removed']) && valueArg.removed === true;
+  }
+  if (methodArg === 'crossharness.chats.list') {
+    return hasFlexExactKeys(valueArg, ['chats'])
+      && Array.isArray(valueArg.chats)
+      && valueArg.chats.length <= 50
+      && valueArg.chats.every(isFlexIntelligenceChatSummary)
+      && Buffer.byteLength(JSON.stringify(valueArg), 'utf8') <= 256 * 1024;
+  }
+  if (methodArg === 'crossharness.chat.read') {
+    return hasFlexExactKeys(valueArg, ['transcript'])
+      && isFlexIntelligenceChatTranscript(valueArg.transcript);
+  }
+  if (methodArg === 'project-management.load') {
+    return hasFlexExactKeys(valueArg, ['record'])
+      && (valueArg.record === null || isFlexProjectManagementRecord(valueArg.record));
+  }
+  if (
+    methodArg === 'project-management.save'
+    || methodArg === 'project-management.tombstone'
+  ) return isFlexProjectManagementCommitResult(valueArg);
+  if (methodArg === 'project-management.purge') {
+    return hasFlexExactKeys(valueArg, ['purged']) && valueArg.purged === true;
+  }
+  if (methodArg === 'browser.resources.resolve') {
+    return hasFlexExactKeys(valueArg, ['resources'])
+      && Array.isArray(valueArg.resources)
+      && valueArg.resources.length <= flexIpcMaximumBrowserChannels
+      && valueArg.resources.every(isFlexBrowserResourceDescriptor)
+      && new Set(valueArg.resources.map((entry) => entry.resourceId)).size
+        === valueArg.resources.length;
+  }
+  if (methodArg === 'browser.channel.open') {
+    return hasFlexExactKeys(valueArg, ['binding', 'capabilityToken'])
+      && isFlexBrowserChannelBinding(valueArg.binding)
+      && isBoundedString(valueArg.capabilityToken, 512)
+      && Buffer.byteLength(valueArg.capabilityToken, 'utf8') >= 16;
+  }
+  return hasFlexExactKeys(valueArg, ['closed']) && valueArg.closed === true;
+};
+
+const isPublicProviderModel = (valueArg: unknown): valueArg is IFlexPublicProviderModel => {
+  if (
+    !isFlexPlainObject(valueArg)
+    || !hasFlexExactKeys(
+      valueArg,
+      [
+        'providerId', 'modelId', 'displayName', 'description', 'hidden',
+        'reasoningEfforts', 'defaultReasoningEffort', 'inputModalities',
+        'supportsPersonality', 'serviceTiers', 'isDefault',
+      ],
+      ['defaultServiceTier'],
+    )
+    || valueArg.providerId !== 'openai'
+    || !isBoundedString(valueArg.modelId, 256)
+    || !isBoundedString(valueArg.displayName, 512)
+    || !isBoundedString(valueArg.description, 2048, true)
+    || typeof valueArg.hidden !== 'boolean'
+    || !Array.isArray(valueArg.reasoningEfforts)
+    || valueArg.reasoningEfforts.length > 16
+    || !valueArg.reasoningEfforts.every((entry) => isFlexPlainObject(entry)
+      && hasFlexExactKeys(entry, ['effort', 'description'])
+      && isBoundedString(entry.effort, 128)
+      && isBoundedString(entry.description, 1024, true))
+    || !isBoundedString(valueArg.defaultReasoningEffort, 128)
+    || !Array.isArray(valueArg.inputModalities)
+    || valueArg.inputModalities.length > 3
+    || !valueArg.inputModalities.every((entry) => ['text', 'image', 'audio'].includes(String(entry)))
+    || typeof valueArg.supportsPersonality !== 'boolean'
+    || !Array.isArray(valueArg.serviceTiers)
+    || valueArg.serviceTiers.length > 16
+    || !valueArg.serviceTiers.every((entry) => isFlexPlainObject(entry)
+      && hasFlexExactKeys(entry, ['id', 'name', 'description'])
+      && isBoundedString(entry.id, 128)
+      && isBoundedString(entry.name, 256)
+      && isBoundedString(entry.description, 1024, true))
+    || (valueArg.defaultServiceTier !== undefined
+      && !isBoundedString(valueArg.defaultServiceTier, 128))
+    || typeof valueArg.isDefault !== 'boolean'
+  ) return false;
+  return true;
+};
+
+const isRateLimitWindow = (valueArg: unknown): valueArg is IFlexPublicProviderRateLimitWindow => (
+  isFlexPlainObject(valueArg)
+  && hasFlexExactKeys(valueArg, [
+    'usedPercent', 'limitWindowSeconds', 'resetAfterSeconds', 'resetsAt',
+  ])
+  && isNonNegativeInteger(valueArg.usedPercent)
+  && valueArg.usedPercent <= 100
+  && isNonNegativeInteger(valueArg.limitWindowSeconds)
+  && valueArg.limitWindowSeconds >= 1
+  && isNonNegativeInteger(valueArg.resetAfterSeconds)
+  && isNonNegativeInteger(valueArg.resetsAt)
+);
+
+const isRateLimitDetails = (valueArg: unknown): valueArg is IFlexPublicProviderRateLimitDetails => (
+  isFlexPlainObject(valueArg)
+  && hasFlexExactKeys(valueArg, ['allowed', 'limitReached'], ['primaryWindow', 'secondaryWindow'])
+  && typeof valueArg.allowed === 'boolean'
+  && typeof valueArg.limitReached === 'boolean'
+  && (valueArg.primaryWindow === undefined || isRateLimitWindow(valueArg.primaryWindow))
+  && (valueArg.secondaryWindow === undefined || isRateLimitWindow(valueArg.secondaryWindow))
+);
+
+const isAccountRateLimits = (
+  valueArg: unknown,
+): valueArg is IFlexPublicProviderAccountRateLimits => isFlexPlainObject(valueArg)
+  && hasFlexExactKeys(
+    valueArg,
+    ['providerId', 'plan', 'observedAt', 'additionalRateLimits'],
+    ['rateLimit', 'rateLimitReachedType', 'rateLimitResetCreditsAvailableCount'],
+  )
+  && valueArg.providerId === 'openai'
+  && isBoundedString(valueArg.plan, 256)
+  && isIsoDate(valueArg.observedAt)
+  && (valueArg.rateLimit === undefined || isRateLimitDetails(valueArg.rateLimit))
+  && Array.isArray(valueArg.additionalRateLimits)
+  && valueArg.additionalRateLimits.length <= 64
+  && valueArg.additionalRateLimits.every((entry) => isFlexPlainObject(entry)
+    && hasFlexExactKeys(entry, ['limitName', 'meteredFeature'], ['rateLimit'])
+    && isBoundedString(entry.limitName, 256)
+    && isBoundedString(entry.meteredFeature, 256)
+    && (entry.rateLimit === undefined || isRateLimitDetails(entry.rateLimit)))
+  && (valueArg.rateLimitReachedType === undefined
+    || isBoundedString(valueArg.rateLimitReachedType, 256))
+  && (valueArg.rateLimitResetCreditsAvailableCount === undefined
+    || isNonNegativeInteger(valueArg.rateLimitResetCreditsAvailableCount));
+
+export const isFlexResponseResult = <TMethod extends TFlexRequestMethod>(
+  methodArg: TMethod,
+  valueArg: unknown,
+): valueArg is TFlexResponse<TMethod> => {
+  switch (methodArg) {
+    case 'service.status':
+      return isFlexServiceStatus(valueArg);
+    case 'project.replaceAll':
+      return isFlexPlainObject(valueArg)
+        && hasFlexExactKeys(valueArg, ['replaced', 'retired'])
+        && valueArg.replaced === true
+        && isNonNegativeInteger(valueArg.retired)
+        && valueArg.retired <= controllerProjectLimit;
+    case 'project.register':
+      return isFlexPlainObject(valueArg)
+        && hasFlexExactKeys(valueArg, ['registered'])
+        && valueArg.registered === true;
+    case 'project.remove':
+      return isFlexPlainObject(valueArg)
+        && hasFlexExactKeys(valueArg, ['removed'])
+        && valueArg.removed === true;
+    case 'intelligence.start':
+      return isFlexPlainObject(valueArg)
+        && hasFlexExactKeys(valueArg, ['jobId', 'workerSessionId'])
+        && isQualifiedId(valueArg.jobId)
+        && isIdentifier(valueArg.workerSessionId);
+    case 'intelligence.get':
+      if (
+        !isFlexPlainObject(valueArg)
+        || !hasFlexExactKeys(
+          valueArg,
+          ['status', 'workerSessionId'],
+          ['result', 'error'],
+        )
+        || !['running', 'completed', 'failed', 'cancelled'].includes(String(valueArg.status))
+        || !isIdentifier(valueArg.workerSessionId)
+        || (valueArg.result !== undefined && !isFlexIntelligenceResult(valueArg.result))
+        || (valueArg.error !== undefined && valueArg.error !== 'Session Intelligence failed.')
+      ) return false;
+      return (valueArg.status === 'completed' && valueArg.result !== undefined
+          && valueArg.error === undefined)
+        || (valueArg.status === 'failed' && valueArg.result === undefined
+          && valueArg.error === 'Session Intelligence failed.')
+        || (valueArg.status === 'cancelled' && valueArg.result === undefined
+          && valueArg.error === undefined)
+        || (valueArg.status === 'running' && valueArg.result === undefined
+          && valueArg.error === undefined);
+    case 'intelligence.cancel':
+      return isFlexPlainObject(valueArg)
+        && hasFlexExactKeys(valueArg, ['cancelled'])
+        && typeof valueArg.cancelled === 'boolean';
+    case 'session.list':
+      return isFlexPlainObject(valueArg)
+        && hasFlexExactKeys(valueArg, ['sessions', 'total', 'truncated'])
+        && Array.isArray(valueArg.sessions) && valueArg.sessions.length <= 50
+        && valueArg.sessions.every(isFlexPublicSession)
+        && isNonNegativeInteger(valueArg.total)
+        && typeof valueArg.truncated === 'boolean';
+    case 'session.create':
+    case 'session.get':
+    case 'session.update':
+      return isFlexPublicSession(valueArg);
+    case 'session.delete':
+      return isFlexPlainObject(valueArg) && hasFlexExactKeys(valueArg, ['deleted'])
+        && valueArg.deleted === true;
+    case 'session.compact':
+      return isFlexPlainObject(valueArg) && hasFlexExactKeys(valueArg, ['compacted'])
+        && valueArg.compacted === true;
+    case 'session.reversion.info':
+      return isSessionReversionInfo(valueArg);
+    case 'slash.list':
+      return isFlexPlainObject(valueArg)
+        && hasFlexExactKeys(valueArg, ['commands'])
+        && Array.isArray(valueArg.commands)
+        && valueArg.commands.length <= 132
+        && valueArg.commands.every(isSlashDescriptor);
+    case 'slash.execute':
+      return isSlashExecutionResult(valueArg);
+    case 'message.page':
+      return isFlexPlainObject(valueArg)
+        && hasFlexExactKeys(valueArg, ['messages'], ['nextCursor'])
+        && Array.isArray(valueArg.messages) && valueArg.messages.length <= 50
+        && valueArg.messages.every(isFlexPublicMessage)
+        && (valueArg.nextCursor === undefined || isBoundedString(valueArg.nextCursor, 4096));
+    case 'message.get':
+      return isFlexPublicMessage(valueArg);
+    case 'prompt.start':
+      return isFlexPlainObject(valueArg)
+        && hasFlexExactKeys(valueArg, ['queueId', 'runId'])
+        && isIdentifier(valueArg.queueId)
+        && isIdentifier(valueArg.runId);
+    case 'prompt.acknowledge':
+      return isFlexPlainObject(valueArg)
+        && hasFlexExactKeys(valueArg, ['acknowledged'])
+        && valueArg.acknowledged === true;
+    case 'prompt.get':
+      return isFlexPlainObject(valueArg)
+        && hasFlexExactKeys(valueArg, ['entry'])
+        && isPromptQueueEntry(valueArg.entry);
+    case 'prompt.list':
+      return isFlexPlainObject(valueArg)
+        && hasFlexExactKeys(valueArg, ['entries'])
+        && Array.isArray(valueArg.entries)
+        && valueArg.entries.length <= flexIpcMaximumPromptQueueEntries
+        && valueArg.entries.every(isPromptQueueEntry);
+    case 'prompt.cancel':
+      return isFlexPlainObject(valueArg) && hasFlexExactKeys(valueArg, ['accepted'])
+        && typeof valueArg.accepted === 'boolean';
+    case 'permission.list':
+      return isFlexPlainObject(valueArg) && hasFlexExactKeys(valueArg, ['permissions'])
+        && Array.isArray(valueArg.permissions) && valueArg.permissions.length <= 64
+        && valueArg.permissions.every(isPermissionRequest);
+    case 'permission.respond':
+    case 'provider.connection.logout.prepare':
+    case 'provider.connection.logout':
+      return isFlexPlainObject(valueArg) && hasFlexExactKeys(valueArg, ['accepted'])
+        && valueArg.accepted === true;
+    case 'provider.connection.ratelimits.get':
+      return isFlexPlainObject(valueArg)
+        && hasFlexExactKeys(valueArg, ['rateLimits'])
+        && isAccountRateLimits(valueArg.rateLimits);
+    case 'provider.list':
+      return isFlexPlainObject(valueArg) && hasFlexExactKeys(valueArg, ['providers'])
+        && Array.isArray(valueArg.providers) && valueArg.providers.length === 1
+        && isFlexPlainObject(valueArg.providers[0])
+        && hasFlexExactKeys(valueArg.providers[0], ['providerId', 'displayName', 'loginFlow'])
+        && valueArg.providers[0].providerId === 'openai'
+        && isBoundedString(valueArg.providers[0].displayName, 256)
+        && valueArg.providers[0].loginFlow === 'device';
+    case 'provider.login.begin':
+      return isFlexPlainObject(valueArg)
+        && hasFlexExactKeys(
+          valueArg,
+          ['loginId', 'verificationUrl', 'userCode', 'status'],
+        )
+        && isQualifiedId(valueArg.loginId)
+        && isBoundedString(valueArg.verificationUrl, 4096)
+        && isBoundedString(valueArg.userCode, 256)
+        && valueArg.status === 'pending';
+    case 'provider.login.status':
+      return isFlexPublicProviderConnection(valueArg);
+    case 'provider.login.cancel':
+      return isFlexPlainObject(valueArg) && hasFlexExactKeys(valueArg, ['canceled'])
+        && typeof valueArg.canceled === 'boolean';
+    case 'provider.connection.list':
+      return isFlexPlainObject(valueArg) && hasFlexExactKeys(valueArg, ['connections'])
+        && Array.isArray(valueArg.connections) && valueArg.connections.length <= 512
+        && valueArg.connections.every(isFlexPublicProviderConnection);
+    case 'provider.connection.opencode-auth.get':
+      return isFlexPlainObject(valueArg) && hasFlexExactKeys(valueArg, ['auth'])
+        && isOpenCodeOAuthAuth(valueArg.auth);
+    case 'provider.models.refresh':
+      return isFlexPlainObject(valueArg) && hasFlexExactKeys(valueArg, ['jobId'])
+        && isQualifiedId(valueArg.jobId);
+    case 'model.choice.get':
+      return isFlexPlainObject(valueArg) && hasFlexExactKeys(valueArg, ['choice'])
+        && (valueArg.choice === null || isModelChoice(valueArg.choice));
+    case 'model.choice.set':
+      return isFlexPlainObject(valueArg) && hasFlexExactKeys(valueArg, ['choice'])
+        && isModelChoice(valueArg.choice);
+    case 'model.choice.validate':
+      return isFlexPlainObject(valueArg)
+        && hasFlexExactKeys(valueArg, ['valid'])
+        && valueArg.valid === true;
+    default:
+      return false;
+  }
+};
+
+export const isFlexServiceError = (valueArg: unknown): valueArg is IFlexServiceError =>
+  isFlexPlainObject(valueArg)
+  && hasFlexExactKeys(valueArg, ['name', 'code', 'message'])
+  && valueArg.name === 'FlexServiceError'
+  && typeof valueArg.code === 'string'
+  && serviceErrorCodes.has(valueArg.code)
+  && valueArg.message === flexServiceErrorMessages[valueArg.code as TFlexServiceErrorCode];
+
+const isFlexChildEvent = (valueArg: unknown): valueArg is TFlexChildEvent => {
+  if (!isFlexPlainObject(valueArg)) return false;
+  switch (valueArg.type) {
+    case 'session.history.changed':
+      return hasFlexExactKeys(
+        valueArg,
+        ['type', 'scopeId', 'sessionId', 'direction'],
+        ['runId'],
+      )
+        && isIdentifier(valueArg.scopeId)
+        && isIdentifier(valueArg.sessionId)
+        && ['undo', 'redo', 'branch'].includes(String(valueArg.direction))
+        && (valueArg.runId === undefined || isIdentifier(valueArg.runId))
+        && (valueArg.direction === 'branch'
+          ? valueArg.runId === undefined
+          : valueArg.runId !== undefined);
+    case 'sessions.changed':
+      return hasFlexExactKeys(valueArg, ['type', 'coalesced'], ['scopeId', 'sessionId'])
+        && typeof valueArg.coalesced === 'boolean'
+        && (valueArg.scopeId === undefined || isIdentifier(valueArg.scopeId))
+        && (valueArg.sessionId === undefined || isIdentifier(valueArg.sessionId))
+        && (valueArg.sessionId === undefined || valueArg.scopeId !== undefined);
+    case 'permissions.changed':
+      return hasFlexExactKeys(valueArg, ['type', 'scopeId', 'sessionId'])
+        && isIdentifier(valueArg.scopeId) && isIdentifier(valueArg.sessionId);
+    case 'tool.updated':
+      return hasFlexExactKeys(valueArg, [
+        'type', 'scopeId', 'sessionId', 'runId', 'messageId',
+        'messageIndex', 'partIndex', 'sequence', 'timestamp', 'part',
+      ])
+        && isIdentifier(valueArg.scopeId)
+        && isIdentifier(valueArg.sessionId)
+        && isIdentifier(valueArg.runId)
+        && isIdentifier(valueArg.messageId)
+        && isNonNegativeInteger(valueArg.messageIndex)
+        && isNonNegativeInteger(valueArg.partIndex)
+        && isNonNegativeInteger(valueArg.sequence)
+        && valueArg.sequence >= 1
+        && isIsoDate(valueArg.timestamp)
+        && isFlexPlainObject(valueArg.part)
+         && valueArg.part.type === 'tool'
+         && isMessagePart(valueArg.part);
+    case 'reasoning.updated':
+      return hasFlexExactKeys(valueArg, [
+        'type', 'scopeId', 'sessionId', 'runId', 'messageId',
+        'messageIndex', 'partIndex', 'sequence', 'timestamp', 'part',
+      ])
+        && isIdentifier(valueArg.scopeId)
+        && isIdentifier(valueArg.sessionId)
+        && isIdentifier(valueArg.runId)
+        && isIdentifier(valueArg.messageId)
+        && isNonNegativeInteger(valueArg.messageIndex)
+        && isNonNegativeInteger(valueArg.partIndex)
+        && isNonNegativeInteger(valueArg.sequence)
+        && valueArg.sequence >= 1
+        && isIsoDate(valueArg.timestamp)
+        && isFlexPlainObject(valueArg.part)
+        && valueArg.part.type === 'reasoning'
+        && isMessagePart(valueArg.part);
+    case 'text.updated':
+      return hasFlexExactKeys(valueArg, [
+        'type', 'scopeId', 'sessionId', 'runId', 'messageId',
+        'messageIndex', 'partIndex', 'sequence', 'timestamp', 'status', 'part',
+      ])
+        && isIdentifier(valueArg.scopeId)
+        && isIdentifier(valueArg.sessionId)
+        && isIdentifier(valueArg.runId)
+        && isIdentifier(valueArg.messageId)
+        && isNonNegativeInteger(valueArg.messageIndex)
+        && isNonNegativeInteger(valueArg.partIndex)
+        && isNonNegativeInteger(valueArg.sequence)
+        && valueArg.sequence >= 1
+        && isIsoDate(valueArg.timestamp)
+        && ['running', 'completed'].includes(String(valueArg.status))
+        && isFlexPlainObject(valueArg.part)
+        && valueArg.part.type === 'text'
+        && isMessagePart(valueArg.part);
+    case 'prompt.queued':
+    case 'prompt.started':
+    case 'prompt.running':
+    case 'prompt.finished':
+      return hasFlexExactKeys(
+        valueArg,
+        ['type', 'scopeId', 'sessionId', 'queueId', 'entry'],
+        ['runId'],
+      )
+        && isIdentifier(valueArg.scopeId)
+        && isIdentifier(valueArg.sessionId)
+        && isIdentifier(valueArg.queueId)
+        && (valueArg.runId === undefined || isIdentifier(valueArg.runId))
+        && isPromptQueueEntry(valueArg.entry)
+        && valueArg.entry.scopeId === valueArg.scopeId
+        && valueArg.entry.sessionId === valueArg.sessionId
+        && valueArg.entry.queueId === valueArg.queueId
+        && valueArg.entry.runId === valueArg.runId
+        && (
+          (valueArg.type === 'prompt.queued'
+            && valueArg.runId === undefined
+            && valueArg.entry.status === 'queued')
+          || (valueArg.type === 'prompt.started'
+            && valueArg.runId !== undefined
+            && ['starting', 'scheduled'].includes(valueArg.entry.status))
+          || (valueArg.type === 'prompt.running'
+            && valueArg.runId !== undefined
+            && valueArg.entry.status === 'running')
+          || (valueArg.type === 'prompt.finished'
+            && valueArg.runId !== undefined
+            && ['completed', 'failed', 'cancelled'].includes(valueArg.entry.status))
+        );
+    case 'prompt.message-bound':
+      return hasFlexExactKeys(valueArg, [
+        'type', 'scopeId', 'sessionId', 'queueId', 'runId', 'messageId',
+      ])
+        && isIdentifier(valueArg.scopeId)
+        && isIdentifier(valueArg.sessionId)
+        && isIdentifier(valueArg.queueId)
+        && isIdentifier(valueArg.runId)
+        && isIdentifier(valueArg.messageId);
+    case 'job.finished':
+      return hasFlexExactKeys(
+        valueArg,
+        ['type', 'jobId', 'kind', 'status'],
+        ['models'],
+      )
+        && isQualifiedId(valueArg.jobId)
+        && valueArg.kind === 'provider.models'
+        && ['completed', 'failed', 'cancelled'].includes(String(valueArg.status))
+        && (valueArg.models === undefined || (
+          valueArg.status === 'completed'
+          && Array.isArray(valueArg.models)
+          && valueArg.models.length <= 256
+          && valueArg.models.every(isPublicProviderModel)
+        ));
+    case 'provider.connection.changed':
+      return hasFlexExactKeys(valueArg, ['type', 'connection'])
+        && isFlexPublicProviderConnection(valueArg.connection);
+    default:
+      return false;
+  }
+};
+
+export const parseFlexParentMessage = (valueArg: unknown): TFlexParentMessage => {
+  if (
+    !isFlexPlainObject(valueArg)
+    || valueArg.version !== flexIpcProtocolVersion
+    || typeof valueArg.type !== 'string'
+  ) throw new Error('Invalid Flex parent message.');
+  if (valueArg.type === 'init') {
+    if (!hasFlexExactKeys(valueArg, ['version', 'type', 'init']) || !isFlexServiceInit(valueArg.init)) {
+      throw new Error('Invalid Flex init message.');
+    }
+    return valueArg as unknown as IFlexIpcInitMessage;
+  }
+  if (valueArg.type === 'request') {
+    if (
+      !hasFlexExactKeys(valueArg, ['version', 'type', 'requestId', 'method', 'payload'])
+      || !isRequestId(valueArg.requestId)
+      || typeof valueArg.method !== 'string'
+      || !requestMethods.has(valueArg.method)
+      || !isFlexRequestPayload(valueArg.method as TFlexRequestMethod, valueArg.payload)
+    ) throw new Error('Invalid Flex request message.');
+    return valueArg as unknown as IFlexIpcRequestMessage;
+  }
+  if (valueArg.type === 'request.cancel') {
+    if (
+      !hasFlexExactKeys(valueArg, ['version', 'type', 'requestId'])
+      || !isRequestId(valueArg.requestId)
+    ) throw new Error('Invalid Flex request cancellation message.');
+    return valueArg as unknown as IFlexIpcRequestCancelMessage;
+  }
+  if (valueArg.type === 'dispose') {
+    if (!hasFlexExactKeys(valueArg, ['version', 'type', 'requestId']) || !isRequestId(valueArg.requestId)) {
+      throw new Error('Invalid Flex dispose message.');
+    }
+    return valueArg as unknown as IFlexIpcDisposeMessage;
+  }
+  if (valueArg.type === 'host.response') {
+    if (!isRequestId(valueArg.requestId) || typeof valueArg.ok !== 'boolean') {
+      throw new Error('Invalid Flex host response message.');
+    }
+    if (valueArg.ok) {
+      if (!hasFlexExactKeys(valueArg, ['version', 'type', 'requestId', 'ok', 'result'])) {
+        throw new Error('Invalid successful Flex host response message.');
+      }
+    } else if (
+      !hasFlexExactKeys(valueArg, ['version', 'type', 'requestId', 'ok', 'error'])
+      || !isFlexServiceError(valueArg.error)
+    ) {
+      throw new Error('Invalid failed Flex host response message.');
+    }
+    return valueArg as unknown as TFlexIpcHostResponseMessage;
+  }
+  if (valueArg.type === 'browser.channel.frame') {
+    if (
+      !hasFlexExactKeys(valueArg, ['version', 'type', 'channelId', 'dataBase64'])
+      || !isChannelId(valueArg.channelId)
+      || !isCanonicalBrowserFrame(valueArg.dataBase64)
+    ) throw new Error('Invalid Flex browser channel frame.');
+    return valueArg as unknown as IFlexIpcParentBrowserFrameMessage;
+  }
+  if (valueArg.type === 'browser.channel.closed') {
+    if (
+      !hasFlexExactKeys(valueArg, ['version', 'type', 'channelId'])
+      || !isChannelId(valueArg.channelId)
+    ) throw new Error('Invalid Flex browser channel close message.');
+    return valueArg as unknown as IFlexIpcBrowserChannelClosedMessage;
+  }
+  throw new Error('Invalid Flex parent message type.');
+};
+
+export const parseFlexChildMessage = (valueArg: unknown): TFlexChildMessage => {
+  if (
+    !isFlexPlainObject(valueArg)
+    || valueArg.version !== flexIpcProtocolVersion
+    || typeof valueArg.type !== 'string'
+  ) throw new Error('Invalid Flex child message.');
+  if (valueArg.type === 'status') {
+    if (!hasFlexExactKeys(valueArg, ['version', 'type', 'status']) || !isFlexServiceStatus(valueArg.status)) {
+      throw new Error('Invalid Flex status message.');
+    }
+    return valueArg as unknown as IFlexIpcStatusMessage;
+  }
+  if (valueArg.type === 'response') {
+    if (!isRequestId(valueArg.requestId) || typeof valueArg.ok !== 'boolean') {
+      throw new Error('Invalid Flex response message.');
+    }
+    if (valueArg.ok) {
+      if (!hasFlexExactKeys(valueArg, ['version', 'type', 'requestId', 'ok', 'result'])) {
+        throw new Error('Invalid successful Flex response message.');
+      }
+    } else if (
+      !hasFlexExactKeys(valueArg, ['version', 'type', 'requestId', 'ok', 'error'])
+      || !isFlexServiceError(valueArg.error)
+    ) {
+      throw new Error('Invalid failed Flex response message.');
+    }
+    return valueArg as unknown as TFlexIpcResponseMessage;
+  }
+  if (valueArg.type === 'event') {
+    if (!hasFlexExactKeys(valueArg, ['version', 'type', 'event']) || !isFlexChildEvent(valueArg.event)) {
+      throw new Error('Invalid Flex event message.');
+    }
+    return valueArg as unknown as IFlexIpcEventMessage;
+  }
+  if (valueArg.type === 'host.request') {
+    if (
+      !hasFlexExactKeys(
+        valueArg,
+        ['version', 'type', 'requestId', 'method', 'payload', 'timeoutMs'],
+      )
+      || !isRequestId(valueArg.requestId)
+      || typeof valueArg.method !== 'string'
+      || !hostRequestMethods.has(valueArg.method)
+      || !Number.isSafeInteger(valueArg.timeoutMs)
+      || Number(valueArg.timeoutMs) < 1
+      || Number(valueArg.timeoutMs) > flexIpcMaximumHostTimeoutMs
+      || !isFlexHostRequestPayload(
+        valueArg.method as TFlexHostRequestMethod,
+        valueArg.payload,
+      )
+    ) throw new Error('Invalid Flex host request message.');
+    return valueArg as unknown as IFlexIpcHostRequestMessage;
+  }
+  if (valueArg.type === 'host.cancel') {
+    if (
+      !hasFlexExactKeys(valueArg, ['version', 'type', 'requestId'])
+      || !isRequestId(valueArg.requestId)
+    ) throw new Error('Invalid Flex host cancellation message.');
+    return valueArg as unknown as IFlexIpcHostCancelMessage;
+  }
+  if (valueArg.type === 'host.response.acknowledge') {
+    if (
+      !hasFlexExactKeys(valueArg, ['version', 'type', 'requestId'])
+      || !isRequestId(valueArg.requestId)
+    ) throw new Error('Invalid Flex host response acknowledgement message.');
+    return valueArg as unknown as IFlexIpcHostResponseAcknowledgementMessage;
+  }
+  if (valueArg.type === 'browser.channel.frame') {
+    if (
+      !hasFlexExactKeys(valueArg, ['version', 'type', 'channelId', 'dataBase64'])
+      || !isChannelId(valueArg.channelId)
+      || !isCanonicalBrowserFrame(valueArg.dataBase64)
+    ) throw new Error('Invalid Flex browser channel frame.');
+    return valueArg as unknown as IFlexIpcChildBrowserFrameMessage;
+  }
+  throw new Error('Invalid Flex child message type.');
+};
+
+export const createFlexServiceError = (
+  codeArg: TFlexServiceErrorCode,
+): IFlexServiceError => ({
+  name: 'FlexServiceError',
+  code: codeArg,
+  message: flexServiceErrorMessages[codeArg],
+});
+
+export class FlexServiceError extends Error {
+  public readonly name = 'FlexServiceError';
+
+  constructor(public readonly code: TFlexServiceErrorCode) {
+    super(flexServiceErrorMessages[code]);
+  }
+}