@otto-code/protocol 0.5.0

package/dist/messages.js

@@ -0,0 +1,4719 @@
+import { z } from "zod";
+import { TerminalActivitySchema } from "./terminal-activity.js";
+import { ArtifactMetadataSchema } from "./artifacts/types.js";
+import { ArtifactListRequestSchema, ArtifactCreateRequestSchema, ArtifactUpdateRequestSchema, ArtifactRegenerateRequestSchema, ArtifactCancelRequestSchema, ArtifactDeleteRequestSchema, ArtifactStarRequestSchema, ArtifactGetContentRequestSchema, ArtifactListResponseSchema, ArtifactCreateResponseSchema, ArtifactUpdateResponseSchema, ArtifactRegenerateResponseSchema, ArtifactCancelResponseSchema, ArtifactDeleteResponseSchema, ArtifactStarResponseSchema, ArtifactGetContentResponseSchema, ArtifactCreatedNotificationSchema, ArtifactUpdatedNotificationSchema, ArtifactDeletedNotificationSchema, } from "./artifacts/rpc-schemas.js";
+import { CLIENT_CAPS } from "./client-capabilities.js";
+import { AGENT_LIFECYCLE_STATUSES } from "./agent-lifecycle.js";
+import { MAX_EXPLICIT_AGENT_TITLE_CHARS } from "./agent-title-limits.js";
+import { AgentProviderSchema } from "./provider-manifest.js";
+import { McpServerConfigSchema, OTTO_TOOL_GROUPS } from "./provider-config.js";
+import { TOOL_CALL_ICON_NAMES } from "./agent-types.js";
+import { ChatCreateRequestSchema, ChatListRequestSchema, ChatInspectRequestSchema, ChatDeleteRequestSchema, ChatPostRequestSchema, ChatReadRequestSchema, ChatWaitRequestSchema, ChatCreateResponseSchema, ChatListResponseSchema, ChatInspectResponseSchema, ChatDeleteResponseSchema, ChatPostResponseSchema, ChatReadResponseSchema, ChatWaitResponseSchema, } from "./chat/rpc-schemas.js";
+import { ScheduleCreateRequestSchema, ScheduleListRequestSchema, ScheduleInspectRequestSchema, ScheduleLogsRequestSchema, SchedulePauseRequestSchema, ScheduleResumeRequestSchema, ScheduleDeleteRequestSchema, ScheduleRunOnceRequestSchema, ScheduleUpdateRequestSchema, ScheduleCreateResponseSchema, ScheduleListResponseSchema, ScheduleInspectResponseSchema, ScheduleLogsResponseSchema, SchedulePauseResponseSchema, ScheduleResumeResponseSchema, ScheduleDeleteResponseSchema, ScheduleRunOnceResponseSchema, ScheduleUpdateResponseSchema, } from "./schedule/rpc-schemas.js";
+import { LoopRunRequestSchema, LoopListRequestSchema, LoopInspectRequestSchema, LoopLogsRequestSchema, LoopStopRequestSchema, LoopRunResponseSchema, LoopListResponseSchema, LoopInspectResponseSchema, LoopLogsResponseSchema, LoopStopResponseSchema, } from "./loop/rpc-schemas.js";
+import { BrowserAutomationExecuteRequestSchema, BrowserAutomationExecuteResponseSchema, } from "./browser-automation/rpc-schemas.js";
+import { BrowserAutomationHostCapabilitySchema } from "./browser-automation/capabilities.js";
+import { OttoConfigRawSchema, OttoLifecycleCommandRawSchema, OttoMetadataGenerationEntrySchema, OttoMetadataGenerationSchema, OttoScriptEntryRawSchema, OttoWorktreeConfigRawSchema, OttoConfigRevisionSchema, ProjectConfigRpcErrorSchema, } from "./otto-config-schema.js";
+import { GitHostingCapabilitiesSchema, GitHostingProviderIdWireSchema } from "./git-hosting.js";
+export { GitHostingCapabilitiesSchema, GitHostingProviderIdSchema, GitHostingProviderIdWireSchema, isGitHostingProviderId, normalizeGitHostingProviderId, GIT_HOSTING_PROVIDER_IDS, } from "./git-hosting.js";
+export { OttoConfigRawSchema, OttoLifecycleCommandRawSchema, OttoMetadataGenerationEntrySchema, OttoMetadataGenerationSchema, OttoScriptEntryRawSchema, OttoWorktreeConfigRawSchema, };
+// ---------------------------------------------------------------------------
+// Mutable daemon config schemas (shared between server store and client)
+// ---------------------------------------------------------------------------
+const MutableDaemonProviderModelSchema = z
+    .object({
+    id: z.string().min(1),
+    label: z.string().min(1),
+    description: z.string().optional(),
+    isDefault: z.boolean().optional(),
+})
+    .passthrough();
+const MutableDaemonProviderConfigSchema = z
+    .object({
+    enabled: z.boolean().optional(),
+    additionalModels: z.array(MutableDaemonProviderModelSchema).optional(),
+    ottoToolGroups: z.array(z.enum(OTTO_TOOL_GROUPS)).optional(),
+})
+    .passthrough();
+const MutableStructuredGenerationProviderSchema = z
+    .object({
+    provider: z.string().min(1),
+    model: z.string().min(1).optional(),
+    thinkingOptionId: z.string().min(1).optional(),
+})
+    .passthrough();
+const MutableMetadataGenerationConfigSchema = z
+    .object({
+    providers: z.array(MutableStructuredGenerationProviderSchema).default([]),
+})
+    .passthrough();
+export const TerminalProfileSchema = z
+    .object({
+    id: z.string(),
+    name: z.string(),
+    command: z.string(),
+    args: z.array(z.string()).optional(),
+    icon: z.string().optional(),
+})
+    .passthrough();
+const MutableBrowserToolsConfigSchema = z
+    .object({
+    enabled: z.boolean().default(false),
+})
+    .passthrough();
+// Speech engine ids and model ids stay plain strings on the wire so adding an
+// engine or model never breaks an older peer; the daemon validates values
+// against its own catalog when applying a patch.
+const MutableSpeechSttConfigSchema = z
+    .object({
+    provider: z.string().optional(),
+    model: z.string().optional(),
+    language: z.string().optional(),
+})
+    .passthrough();
+const MutableSpeechTtsConfigSchema = z
+    .object({
+    provider: z.string().optional(),
+    model: z.string().optional(),
+    // Voice name (e.g. "af_heart" for local Kokoro, "alloy" for OpenAI). The
+    // daemon maps local voice names to sherpa speaker ids internally.
+    voice: z.string().optional(),
+    speed: z.number().optional(),
+})
+    .passthrough();
+const MutableSpeechDictationConfigSchema = z
+    .object({
+    enabled: z.boolean().optional(),
+    stt: MutableSpeechSttConfigSchema.optional(),
+})
+    .passthrough();
+const MutableSpeechVoiceModeConfigSchema = z
+    .object({
+    enabled: z.boolean().optional(),
+    stt: MutableSpeechSttConfigSchema.optional(),
+    tts: MutableSpeechTtsConfigSchema.optional(),
+})
+    .passthrough();
+// Credentials for the OpenAI speech engine. The key persists to config.json
+// (providers.openai.apiKey) like provider env keys do, and is echoed back in
+// get_daemon_config_response the same way provider connection keys are.
+const MutableSpeechOpenAiConfigSchema = z
+    .object({
+    apiKey: z.string().optional(),
+})
+    .passthrough();
+export const MutableSpeechConfigSchema = z
+    .object({
+    dictation: MutableSpeechDictationConfigSchema.optional(),
+    voiceMode: MutableSpeechVoiceModeConfigSchema.optional(),
+    openai: MutableSpeechOpenAiConfigSchema.optional(),
+})
+    .passthrough();
+// Host-level git hosting credentials, one set per provider. A workspace's
+// provider is derived from its git remote (bitbucket.org → Bitbucket,
+// github.com → GitHub), so credentials are configured once per host, not per
+// project. Keys persist to $OTTO_HOME/config.json and are echoed in
+// get_daemon_config_response the same way provider connection keys are.
+const MutableGitHostingBitbucketCloudConfigSchema = z
+    .object({
+    // Atlassian account email + API token, sent as HTTP Basic auth.
+    email: z.string().optional(),
+    apiToken: z.string().optional(),
+})
+    .passthrough();
+const MutableGitHostingProvidersConfigSchema = z
+    .object({
+    bitbucketCloud: MutableGitHostingBitbucketCloudConfigSchema.optional(),
+})
+    .passthrough();
+export const MutableGitHostingConfigSchema = z
+    .object({
+    providers: MutableGitHostingProvidersConfigSchema.optional(),
+})
+    .passthrough();
+// Canonical personality roles, in display order. Kept as an exported const so
+// the daemon and app share one vocabulary, but the wire schema stores roles as
+// plain strings (below) — adding an 8th role later must never break an older
+// peer's parsing. Consumers filter incoming role arrays to this known set.
+export const PERSONALITY_ROLES = [
+    "chatter",
+    "artificer",
+    "scheduler",
+    "worker",
+    "judger",
+    "advisor",
+    "orchestrator",
+];
+// Two glow colors for the personality's thinking spinner (BlobLoader glowA/glowB).
+const AgentPersonalitySpinnerSchema = z
+    .object({
+    glowA: z.string().min(1),
+    glowB: z.string().min(1),
+})
+    .passthrough();
+// A TTS voice for the personality's spoken identity. Stored self-describing —
+// provider + model + voice name — because voice names are namespaced per TTS
+// engine/model (the same speaker index maps to different names across models),
+// so a bare name is ambiguous across hosts. All plain strings (like the speech
+// config) for forward-compat. This is a soft binding: an unavailable voice
+// degrades to the host default at playback time, it never takes the personality
+// out of commission.
+const AgentPersonalityVoiceSchema = z
+    .object({
+    provider: z.string().min(1),
+    model: z.string().min(1),
+    name: z.string().min(1),
+})
+    .passthrough();
+// A named, reusable agent template stored per-host. `id` is the stable identity
+// everything binds to; `name` is a freely-renamable label. Effort and roles are
+// plain strings on the wire (like speech engine/model ids) so the daemon can
+// grow the vocabulary without breaking old peers; the daemon validates them
+// against its own catalog when applying a patch.
+export const AgentPersonalitySchema = z
+    .object({
+    id: z.string().min(1),
+    name: z.string().min(1),
+    provider: z.string().min(1),
+    model: z.string().min(1),
+    // Canonical effort level ("off".."max"); resolved to the bound model's
+    // nearest advertised option at spawn.
+    effortLevel: z.string().min(1).optional(),
+    modeId: z.string().min(1).optional(),
+    personalityPrompt: z.string().optional(),
+    // Default true: the daemon-global appendSystemPrompt still stacks on top of
+    // the personality prompt. False = the personality prompt stands alone.
+    respectGlobalAppendPrompt: z.boolean().optional(),
+    roles: z.array(z.string().min(1)).optional(),
+    spinner: AgentPersonalitySpinnerSchema.optional(),
+    voice: AgentPersonalityVoiceSchema.optional(),
+})
+    .passthrough();
+const MutableAgentPersonalitiesConfigSchema = z
+    .object({
+    personalities: z.array(AgentPersonalitySchema).default([]),
+})
+    .passthrough();
+export const MutableDaemonConfigSchema = z
+    .object({
+    mcp: z
+        .object({
+        injectIntoAgents: z.boolean(),
+    })
+        .passthrough(),
+    browserTools: MutableBrowserToolsConfigSchema.default({ enabled: false }),
+    providers: z.record(z.string(), MutableDaemonProviderConfigSchema).default({}),
+    metadataGeneration: MutableMetadataGenerationConfigSchema.default({ providers: [] }),
+    autoArchiveAfterMerge: z.boolean().default(false),
+    enableTerminalAgentHooks: z.boolean().default(false),
+    appendSystemPrompt: z.string().default(""),
+    terminalProfiles: z.array(TerminalProfileSchema).optional(),
+    // Absent on daemons without the speechSettings feature.
+    speech: MutableSpeechConfigSchema.optional(),
+    // Absent on daemons without the gitHostingProviders feature.
+    gitHosting: MutableGitHostingConfigSchema.optional(),
+    // Per-host agent personality roster. Gated by the agentPersonalities
+    // feature; defaults to an empty roster so a new client parsing an old
+    // daemon's config still sees a well-formed section.
+    agentPersonalities: MutableAgentPersonalitiesConfigSchema.default({ personalities: [] }),
+})
+    .passthrough();
+export const MutableDaemonConfigPatchSchema = z
+    .object({
+    mcp: MutableDaemonConfigSchema.shape.mcp.partial().optional(),
+    browserTools: MutableBrowserToolsConfigSchema.partial().optional(),
+    // A null entry removes the provider's config entirely (custom provider
+    // uninstall). Gated by server_info features.providerRemove — old daemons
+    // reject null values.
+    providers: z
+        .record(z.string(), MutableDaemonProviderConfigSchema.partial().passthrough().nullable())
+        .optional(),
+    metadataGeneration: MutableMetadataGenerationConfigSchema.partial().optional(),
+    autoArchiveAfterMerge: z.boolean().optional(),
+    enableTerminalAgentHooks: z.boolean().optional(),
+    appendSystemPrompt: z.string().optional(),
+    terminalProfiles: z.array(TerminalProfileSchema).optional(),
+    // Gated by server_info features.speechSettings; every field is optional so
+    // patches deep-merge into the daemon's current speech config.
+    speech: MutableSpeechConfigSchema.optional(),
+    // Gated by server_info features.gitHostingProviders; patches deep-merge.
+    gitHosting: MutableGitHostingConfigSchema.optional(),
+    // Gated by server_info features.agentPersonalities. A patch replaces the
+    // full roster (read-modify-write the array), matching how terminalProfiles
+    // and metadataGeneration.providers patch.
+    agentPersonalities: MutableAgentPersonalitiesConfigSchema.partial().optional(),
+})
+    .partial()
+    .passthrough();
+export const AgentStatusSchema = z.enum(AGENT_LIFECYCLE_STATUSES);
+const AgentModeSchema = z.object({
+    id: z.string(),
+    label: z.string(),
+    description: z.string().optional(),
+    icon: z.string().optional(),
+    colorTier: z.string().optional(),
+});
+const ProviderStatusSchema = z.enum([
+    "ready",
+    "loading",
+    "error",
+    "unavailable",
+]);
+const AgentSelectOptionSchema = z.object({
+    id: z.string(),
+    label: z.string(),
+    description: z.string().optional(),
+    isDefault: z.boolean().optional(),
+    metadata: z.record(z.string(), z.unknown()).optional(),
+});
+const AgentProviderNoticeSchema = z.discriminatedUnion("type", [
+    z.object({ type: z.literal("info"), message: z.string() }),
+    z.object({ type: z.literal("warning"), message: z.string() }),
+    z.object({ type: z.literal("error"), message: z.string() }),
+]);
+export const AgentFeatureToggleSchema = z.object({
+    type: z.literal("toggle"),
+    id: z.string(),
+    label: z.string(),
+    description: z.string().optional(),
+    tooltip: z.string().optional(),
+    icon: z.string().optional(),
+    value: z.boolean(),
+});
+export const AgentFeatureSelectSchema = z.object({
+    type: z.literal("select"),
+    id: z.string(),
+    label: z.string(),
+    description: z.string().optional(),
+    tooltip: z.string().optional(),
+    icon: z.string().optional(),
+    value: z.string().nullable(),
+    options: z.array(AgentSelectOptionSchema),
+});
+export const AgentFeatureSchema = z.discriminatedUnion("type", [
+    AgentFeatureToggleSchema,
+    AgentFeatureSelectSchema,
+]);
+const AgentModelDefinitionSchema = z.object({
+    provider: AgentProviderSchema,
+    id: z.string(),
+    label: z.string(),
+    description: z.string().optional(),
+    isDefault: z.boolean().optional(),
+    metadata: z.record(z.string(), z.unknown()).optional(),
+    contextWindowMaxTokens: z.number().optional(),
+    thinkingOptions: z.array(AgentSelectOptionSchema).optional(),
+    defaultThinkingOptionId: z.string().optional(),
+});
+export const ProviderSnapshotEntrySchema = z.object({
+    provider: AgentProviderSchema,
+    status: ProviderStatusSchema,
+    enabled: z.boolean().optional().default(true),
+    error: z.string().optional(),
+    models: z.array(AgentModelDefinitionSchema).optional(),
+    modes: z.array(AgentModeSchema).optional(),
+    fetchedAt: z.string().optional(),
+    label: z.string().optional(),
+    description: z.string().optional(),
+    defaultModeId: z.string().nullable().optional(),
+});
+const AgentCapabilityFlagsSchema = z
+    .object({
+    supportsStreaming: z.boolean(),
+    supportsSessionPersistence: z.boolean(),
+    supportsSessionListing: z.boolean().optional(),
+    supportsDynamicModes: z.boolean(),
+    supportsMcpServers: z.boolean(),
+    supportsReasoningStream: z.boolean(),
+    supportsToolInvocations: z.boolean(),
+    // COMPAT(rewind): added in v0.1.X, drop when floor >= v0.1.X.
+    supportsRewindConversation: z.boolean().optional().default(false),
+    // COMPAT(rewind): added in v0.1.X, drop when floor >= v0.1.X.
+    supportsRewindFiles: z.boolean().optional().default(false),
+    // COMPAT(rewind): added in v0.1.X, drop when floor >= v0.1.X.
+    supportsRewindBoth: z.boolean().optional().default(false),
+})
+    .catchall(z.boolean());
+const AgentUsageSchema = z.object({
+    inputTokens: z.number().optional(),
+    cachedInputTokens: z.number().optional(),
+    outputTokens: z.number().optional(),
+    totalCostUsd: z.number().optional(),
+    contextWindowMaxTokens: z.number().optional(),
+    contextWindowUsedTokens: z.number().optional(),
+});
+const AgentSessionConfigSchema = z.object({
+    provider: AgentProviderSchema,
+    cwd: z.string(),
+    modeId: z.string().optional(),
+    model: z.string().optional(),
+    thinkingOptionId: z.string().optional(),
+    featureValues: z.record(z.string(), z.unknown()).optional(),
+    title: z.string().trim().min(1).max(MAX_EXPLICIT_AGENT_TITLE_CHARS).optional().nullable(),
+    approvalPolicy: z.string().optional(),
+    sandboxMode: z.string().optional(),
+    networkAccess: z.boolean().optional(),
+    webSearch: z.boolean().optional(),
+    extra: z
+        .object({
+        codex: z.record(z.string(), z.unknown()).optional(),
+        claude: z.record(z.string(), z.unknown()).optional(),
+    })
+        .partial()
+        .optional(),
+    systemPrompt: z.string().optional(),
+    mcpServers: z.record(z.string(), McpServerConfigSchema).optional(),
+});
+const AgentPermissionUpdateSchema = z.record(z.string(), z.unknown());
+const AgentPermissionActionSchema = z.object({
+    id: z.string(),
+    label: z.string(),
+    behavior: z.enum(["allow", "deny"]),
+    variant: z.enum(["primary", "secondary", "danger"]).optional(),
+    intent: z.enum(["implement", "implement_resume", "dismiss"]).optional(),
+});
+export const AgentPermissionResponseSchema = z.discriminatedUnion("behavior", [
+    z.object({
+        behavior: z.literal("allow"),
+        selectedActionId: z.string().optional(),
+        updatedInput: z.record(z.string(), z.unknown()).optional(),
+        updatedPermissions: z.array(AgentPermissionUpdateSchema).optional(),
+    }),
+    z.object({
+        behavior: z.literal("deny"),
+        selectedActionId: z.string().optional(),
+        message: z.string().optional(),
+        interrupt: z.boolean().optional(),
+    }),
+]);
+export const AgentPermissionRequestPayloadSchema = z.object({
+    id: z.string(),
+    provider: AgentProviderSchema,
+    name: z.string(),
+    kind: z.enum(["tool", "plan", "question", "mode", "other"]),
+    title: z.string().optional(),
+    description: z.string().optional(),
+    input: z.record(z.string(), z.unknown()).optional(),
+    detail: z.lazy(() => ToolCallDetailPayloadSchema).optional(),
+    suggestions: z.array(AgentPermissionUpdateSchema).optional(),
+    actions: z.array(AgentPermissionActionSchema).optional(),
+    metadata: z.record(z.string(), z.unknown()).optional(),
+});
+const UnknownValueSchema = z.union([
+    z.null(),
+    z.boolean(),
+    z.number(),
+    z.string(),
+    z.array(z.unknown()),
+    z.object({}).passthrough(),
+]);
+const NonNullUnknownSchema = z.union([
+    z.boolean(),
+    z.number(),
+    z.string(),
+    z.array(z.unknown()),
+    z.object({}).passthrough(),
+]);
+const WorktreeSetupCommandSnapshotSchema = z.object({
+    index: z.number().int().positive(),
+    command: z.string(),
+    cwd: z.string(),
+    log: z.string().optional().default(""),
+    status: z.enum(["running", "completed", "failed"]),
+    exitCode: z.number().nullable(),
+    durationMs: z.number().nonnegative().optional(),
+});
+const WorktreeSetupDetailPayloadSchema = z.object({
+    type: z.literal("worktree_setup"),
+    worktreePath: z.string(),
+    branchName: z.string(),
+    log: z.string(),
+    commands: z.array(WorktreeSetupCommandSnapshotSchema),
+    truncated: z.boolean().optional(),
+});
+const ToolCallDetailPayloadSchema = z.discriminatedUnion("type", [
+    WorktreeSetupDetailPayloadSchema,
+    z.object({
+        type: z.literal("shell"),
+        command: z.string(),
+        cwd: z.string().optional(),
+        output: z.string().optional(),
+        exitCode: z.number().nullable().optional(),
+    }),
+    z.object({
+        type: z.literal("read"),
+        filePath: z.string(),
+        content: z.string().optional(),
+        offset: z.number().optional(),
+        limit: z.number().optional(),
+    }),
+    z.object({
+        type: z.literal("edit"),
+        filePath: z.string(),
+        oldString: z.string().optional(),
+        newString: z.string().optional(),
+        unifiedDiff: z.string().optional(),
+    }),
+    z.object({
+        type: z.literal("write"),
+        filePath: z.string(),
+        content: z.string().optional(),
+    }),
+    z.object({
+        type: z.literal("search"),
+        query: z.string(),
+        toolName: z.enum(["search", "grep", "glob", "web_search"]).optional(),
+        content: z.string().optional(),
+        filePaths: z.array(z.string()).optional(),
+        webResults: z
+            .array(z.object({
+            title: z.string(),
+            url: z.string(),
+        }))
+            .optional(),
+        annotations: z.array(z.string()).optional(),
+        numFiles: z.number().optional(),
+        numMatches: z.number().optional(),
+        durationMs: z.number().optional(),
+        durationSeconds: z.number().optional(),
+        truncated: z.boolean().optional(),
+        mode: z.enum(["content", "files_with_matches", "count"]).optional(),
+    }),
+    z.object({
+        type: z.literal("fetch"),
+        url: z.string(),
+        prompt: z.string().optional(),
+        result: z.string().optional(),
+        code: z.number().optional(),
+        codeText: z.string().optional(),
+        bytes: z.number().optional(),
+        durationMs: z.number().optional(),
+    }),
+    z.object({
+        type: z.literal("sub_agent"),
+        subAgentType: z.string().optional(),
+        description: z.string().optional(),
+        childSessionId: z.string().optional(),
+        log: z.string(),
+        // Compat cruft for clients <= 0.1.65-beta.3 that required this field. Producers still
+        // emit `[]`; nothing reads it. Drop the field (and the `[]` emissions) once those
+        // clients are no longer in the field.
+        actions: z
+            .array(z.object({
+            index: z.number().int().positive(),
+            toolName: z.string(),
+            summary: z.string().optional(),
+        }))
+            .optional(),
+    }),
+    z.object({
+        type: z.literal("plain_text"),
+        label: z.string().optional(),
+        text: z.string().optional(),
+        icon: z.enum(TOOL_CALL_ICON_NAMES).optional(),
+    }),
+    z.object({
+        type: z.literal("plan"),
+        text: z.string(),
+    }),
+    z.object({
+        type: z.literal("unknown"),
+        input: UnknownValueSchema,
+        output: UnknownValueSchema,
+    }),
+]);
+const ToolCallBasePayloadSchema = z.object({
+    type: z.literal("tool_call"),
+    callId: z.string(),
+    name: z.string(),
+    detail: ToolCallDetailPayloadSchema,
+    metadata: z.record(z.string(), z.unknown()).optional(),
+});
+const ToolCallRunningPayloadSchema = ToolCallBasePayloadSchema.extend({
+    status: z.literal("running"),
+    error: z.null(),
+});
+const ToolCallCompletedPayloadSchema = ToolCallBasePayloadSchema.extend({
+    status: z.literal("completed"),
+    error: z.null(),
+});
+const ToolCallFailedPayloadSchema = ToolCallBasePayloadSchema.extend({
+    status: z.literal("failed"),
+    error: NonNullUnknownSchema,
+});
+const ToolCallCanceledPayloadSchema = ToolCallBasePayloadSchema.extend({
+    status: z.literal("canceled"),
+    error: z.null(),
+});
+const ToolCallTimelineItemPayloadSchema = z.discriminatedUnion("status", [
+    ToolCallRunningPayloadSchema,
+    ToolCallCompletedPayloadSchema,
+    ToolCallFailedPayloadSchema,
+    ToolCallCanceledPayloadSchema,
+]);
+// zod-aot 0.20.4 miscompiles this as a nested discriminated union by omitting
+// the inner tool_call branch from the generated outer dispatch.
+export const AgentTimelineItemPayloadSchema = z.union([
+    z.object({
+        type: z.literal("user_message"),
+        text: z.string(),
+        messageId: z.string().optional(),
+    }),
+    z.object({
+        type: z.literal("assistant_message"),
+        text: z.string(),
+        messageId: z.string().optional(),
+    }),
+    z.object({
+        type: z.literal("reasoning"),
+        text: z.string(),
+    }),
+    ToolCallTimelineItemPayloadSchema,
+    z.object({
+        type: z.literal("todo"),
+        items: z.array(z.object({
+            text: z.string(),
+            completed: z.boolean(),
+        })),
+    }),
+    z.object({
+        type: z.literal("error"),
+        message: z.string(),
+    }),
+    z.object({
+        type: z.literal("compaction"),
+        // COMPAT(compactionFailedStatus): "failed" added in v0.4.3. Clients older
+        // than that drop the whole timeline event on parse and keep showing the
+        // loading row — exactly their pre-"failed" behavior, so no gate is needed.
+        status: z.enum(["loading", "completed", "failed"]),
+        trigger: z.enum(["auto", "manual"]).optional(),
+        preTokens: z.number().optional(),
+        postTokens: z.number().optional(),
+    }),
+]);
+export const AgentStreamEventPayloadSchema = z.discriminatedUnion("type", [
+    z.object({
+        type: z.literal("thread_started"),
+        sessionId: z.string(),
+        provider: AgentProviderSchema,
+    }),
+    z.object({
+        type: z.literal("turn_started"),
+        provider: AgentProviderSchema,
+    }),
+    z.object({
+        type: z.literal("turn_completed"),
+        provider: AgentProviderSchema,
+        usage: AgentUsageSchema.optional(),
+    }),
+    z.object({
+        type: z.literal("turn_failed"),
+        provider: AgentProviderSchema,
+        error: z.string(),
+        code: z.string().optional(),
+        diagnostic: z.string().optional(),
+    }),
+    z.object({
+        type: z.literal("turn_canceled"),
+        provider: AgentProviderSchema,
+        reason: z.string(),
+    }),
+    z.object({
+        type: z.literal("timeline"),
+        provider: AgentProviderSchema,
+        item: AgentTimelineItemPayloadSchema,
+    }),
+    z.object({
+        type: z.literal("permission_requested"),
+        provider: AgentProviderSchema,
+        request: AgentPermissionRequestPayloadSchema,
+    }),
+    z.object({
+        type: z.literal("permission_resolved"),
+        provider: AgentProviderSchema,
+        requestId: z.string(),
+        resolution: AgentPermissionResponseSchema,
+    }),
+    z.object({
+        type: z.literal("attention_required"),
+        provider: AgentProviderSchema,
+        reason: z.enum(["finished", "error", "permission"]),
+        timestamp: z.string(),
+        shouldNotify: z.boolean(),
+        notification: z
+            .object({
+            title: z.string(),
+            body: z.string(),
+            data: z.object({
+                serverId: z.string(),
+                agentId: z.string(),
+                reason: z.enum(["finished", "error", "permission"]),
+            }),
+        })
+            .optional(),
+    }),
+]);
+const AgentPersistenceHandleSchema = z
+    .object({
+    provider: AgentProviderSchema,
+    sessionId: z.string(),
+    nativeHandle: z.string().optional(),
+    metadata: z.record(z.string(), z.unknown()).optional(),
+})
+    .nullable();
+const AgentRuntimeInfoSchema = z.object({
+    provider: AgentProviderSchema,
+    sessionId: z.string().nullable(),
+    model: z.string().nullable().optional(),
+    thinkingOptionId: z.string().nullable().optional(),
+    modeId: z.string().nullable().optional(),
+    extra: z.record(z.string(), z.unknown()).optional(),
+});
+export const AgentSnapshotPayloadSchema = z.object({
+    id: z.string(),
+    provider: AgentProviderSchema,
+    cwd: z.string(),
+    workspaceId: z.string().optional(),
+    model: z.string().nullable(),
+    features: z.array(AgentFeatureSchema).optional(),
+    thinkingOptionId: z.string().nullable().optional(),
+    effectiveThinkingOptionId: z.string().nullable().optional(),
+    createdAt: z.string(),
+    updatedAt: z.string(),
+    lastUserMessageAt: z.string().nullable(),
+    status: AgentStatusSchema,
+    capabilities: AgentCapabilityFlagsSchema,
+    currentModeId: z.string().nullable(),
+    availableModes: z.array(AgentModeSchema),
+    pendingPermissions: z.array(AgentPermissionRequestPayloadSchema),
+    persistence: AgentPersistenceHandleSchema.nullable(),
+    runtimeInfo: AgentRuntimeInfoSchema.optional(),
+    lastUsage: AgentUsageSchema.optional(),
+    lastError: z.string().optional(),
+    title: z.string().nullable(),
+    labels: z.record(z.string(), z.string()).default({}),
+    requiresAttention: z.boolean().optional(),
+    attentionReason: z.enum(["finished", "error", "permission"]).nullable().optional(),
+    attentionTimestamp: z.string().nullable().optional(),
+    archivedAt: z.string().nullable().optional(),
+    providerUnavailable: z.boolean().optional(),
+    // Attendability. "observed" marks a provider-managed subagent (Claude Task /
+    // ultracode fan-out) that the user can watch but not prompt or reconfigure —
+    // the daemon refuses attended operations and the client renders it read-only.
+    // COMPAT(observedSubagents): added in v0.4.3; absent ⇒ "attended". Drop the
+    // gate when daemon floor >= v0.4.3. See projects/observed-subagents/observed-subagents.md.
+    attend: z.enum(["attended", "observed"]).optional(),
+    // Spinner colors from the Agent Personality this agent was spawned from, so
+    // its live thinking indicator renders in the personality's identity. Absent ⇒
+    // the client falls back to the theme's default spinner colors. Purely additive
+    // (no daemon floor needed). See projects/agent-personalities/.
+    personalitySpinner: AgentPersonalitySpinnerSchema.optional(),
+    // Name of the Agent Personality this agent was spawned from, so the running
+    // agent's controls keep showing the personality identity (trigger label +
+    // effort hidden) instead of reverting to the raw model. Absent ⇒ no bound
+    // personality. Purely additive. See projects/agent-personalities/.
+    personalityName: z.string().optional(),
+    // Stable id of the bound Agent Personality. The client keys roster selection
+    // on this (names can be renamed/duplicated); personalityName remains for
+    // display and as the selection fallback against daemons that predate this
+    // field. Purely additive. See projects/agent-personalities/.
+    personalityId: z.string().optional(),
+});
+export const AgentListItemPayloadSchema = z.object({
+    id: z.string(),
+    shortId: z.string(),
+    title: z.string().nullable(),
+    provider: AgentProviderSchema,
+    model: z.string().nullable(),
+    thinkingOptionId: z.string().nullable().optional(),
+    effectiveThinkingOptionId: z.string().nullable().optional(),
+    status: AgentStatusSchema,
+    cwd: z.string(),
+    createdAt: z.string(),
+    updatedAt: z.string(),
+    lastUserMessageAt: z.string().nullable(),
+    archivedAt: z.string().nullable().optional(),
+    requiresAttention: z.boolean().optional(),
+    attentionReason: z.enum(["finished", "error", "permission"]).nullable().optional(),
+    attentionTimestamp: z.string().nullable().optional(),
+    labels: z.record(z.string(), z.string()).default({}),
+    providerUnavailable: z.boolean().optional(),
+});
+export const RecentProviderSessionDescriptorPayloadSchema = z.object({
+    providerId: z.string(),
+    providerLabel: z.string(),
+    providerHandleId: z.string(),
+    cwd: z.string(),
+    title: z.string().nullable(),
+    firstPromptPreview: z.string().nullable(),
+    lastPromptPreview: z.string().nullable(),
+    lastActivityAt: z.string(),
+});
+// ============================================================================
+// Session Inbound Messages (Session receives these)
+// ============================================================================
+export const VoiceAudioChunkMessageSchema = z.object({
+    type: z.literal("voice_audio_chunk"),
+    audio: z.string(), // base64 encoded
+    format: z.string(),
+    isLast: z.boolean(),
+});
+export const AbortRequestMessageSchema = z.object({
+    type: z.literal("abort_request"),
+});
+export const AudioPlayedMessageSchema = z.object({
+    type: z.literal("audio_played"),
+    id: z.string(),
+});
+const AgentDirectoryFilterSchema = z.object({
+    labels: z.record(z.string(), z.string()).optional(),
+    projectKeys: z.array(z.string()).optional(),
+    statuses: z.array(AgentStatusSchema).optional(),
+    includeArchived: z.boolean().optional(),
+    requiresAttention: z.boolean().optional(),
+    thinkingOptionId: z.string().nullable().optional(),
+});
+export const DeleteAgentRequestMessageSchema = z.object({
+    type: z.literal("delete_agent_request"),
+    agentId: z.string(),
+    requestId: z.string(),
+});
+export const ArchiveAgentRequestMessageSchema = z.object({
+    type: z.literal("archive_agent_request"),
+    agentId: z.string(),
+    requestId: z.string(),
+});
+export const CloseItemsRequestMessageSchema = z.object({
+    type: z.literal("close_items_request"),
+    agentIds: z.array(z.string()).default([]),
+    terminalIds: z.array(z.string()).default([]),
+    requestId: z.string(),
+});
+export const UpdateAgentRequestMessageSchema = z.object({
+    type: z.literal("update_agent_request"),
+    agentId: z.string(),
+    name: z.string().optional(),
+    labels: z.record(z.string(), z.string()).optional(),
+    requestId: z.string(),
+});
+export const ProjectRenameRequestSchema = z.object({
+    type: z.literal("project.rename.request"),
+    projectId: z.string(),
+    // Null or empty string clears the override and reverts to the derived name.
+    customName: z.string().nullable(),
+    requestId: z.string(),
+});
+export const ProjectRemoveRequestSchema = z.object({
+    type: z.literal("project.remove.request"),
+    projectId: z.string(),
+    requestId: z.string(),
+});
+export const WorkspaceTitleSetRequestSchema = z.object({
+    type: z.literal("workspace.title.set.request"),
+    workspaceId: z.string(),
+    // Null or empty string clears the title and reverts to the derived name.
+    title: z.string().nullable(),
+    requestId: z.string(),
+});
+export const SetVoiceModeMessageSchema = z.object({
+    type: z.literal("set_voice_mode"),
+    enabled: z.boolean(),
+    agentId: z.string().optional(),
+    requestId: z.string().optional(),
+});
+export const GitHubPrAttachmentSchema = z.object({
+    type: z.literal("github_pr"),
+    mimeType: z.literal("application/github-pr"),
+    number: z.number().int().positive(),
+    title: z.string(),
+    url: z.string(),
+    body: z.string().nullable().optional(),
+    baseRefName: z.string().nullable().optional(),
+    headRefName: z.string().nullable().optional(),
+});
+export const GitHubIssueAttachmentSchema = z.object({
+    type: z.literal("github_issue"),
+    mimeType: z.literal("application/github-issue"),
+    number: z.number().int().positive(),
+    title: z.string(),
+    url: z.string(),
+    body: z.string().nullable().optional(),
+});
+// Provider-neutral successors to github_pr/github_issue. New clients send
+// these when server_info features.gitHostingProviders is set; the github_*
+// kinds remain accepted forever (protocol contract) and are still what a new
+// client sends to an old daemon for GitHub projects.
+export const HostingPrAttachmentSchema = z.object({
+    type: z.literal("hosting_pr"),
+    mimeType: z.literal("application/otto-hosting-pr"),
+    provider: GitHostingProviderIdWireSchema,
+    number: z.number().int().positive(),
+    title: z.string(),
+    url: z.string(),
+    body: z.string().nullable().optional(),
+    baseRefName: z.string().nullable().optional(),
+    headRefName: z.string().nullable().optional(),
+});
+export const HostingIssueAttachmentSchema = z.object({
+    type: z.literal("hosting_issue"),
+    mimeType: z.literal("application/otto-hosting-issue"),
+    provider: GitHostingProviderIdWireSchema,
+    number: z.number().int().positive(),
+    title: z.string(),
+    url: z.string(),
+    body: z.string().nullable().optional(),
+});
+export const TextAttachmentSchema = z
+    .object({
+    type: z.literal("text"),
+    mimeType: z.literal("text/plain"),
+    contextKind: z.string().optional(),
+    title: z.string().nullable().optional(),
+    text: z.string(),
+})
+    .transform(({ contextKind, ...attachment }) => ({
+    ...attachment,
+    ...(contextKind === "chat_history" ? { contextKind } : {}),
+}));
+export const ReviewAttachmentContextLineSchema = z.object({
+    oldLineNumber: z.number().int().positive().nullable(),
+    newLineNumber: z.number().int().positive().nullable(),
+    type: z.enum(["add", "remove", "context"]),
+    content: z.string(),
+});
+export const ReviewAttachmentCommentSchema = z.object({
+    filePath: z.string(),
+    side: z.enum(["old", "new"]),
+    lineNumber: z.number().int().positive(),
+    body: z.string(),
+    context: z.object({
+        hunkHeader: z.string(),
+        targetLine: ReviewAttachmentContextLineSchema,
+        lines: z.array(ReviewAttachmentContextLineSchema),
+    }),
+});
+export const ReviewAttachmentSchema = z.object({
+    type: z.literal("review"),
+    mimeType: z.literal("application/otto-review"),
+    cwd: z.string(),
+    mode: z.enum(["uncommitted", "base"]),
+    baseRef: z.string().nullable().optional(),
+    comments: z.array(ReviewAttachmentCommentSchema),
+});
+export const UploadedFileAttachmentSchema = z.object({
+    type: z.literal("uploaded_file"),
+    id: z.string(),
+    fileName: z.string(),
+    mimeType: z.string(),
+    size: z.number().int().nonnegative(),
+    path: z.string(),
+});
+export const AgentAttachmentSchema = z.discriminatedUnion("type", [
+    GitHubPrAttachmentSchema,
+    GitHubIssueAttachmentSchema,
+    HostingPrAttachmentSchema,
+    HostingIssueAttachmentSchema,
+    TextAttachmentSchema,
+    ReviewAttachmentSchema,
+    UploadedFileAttachmentSchema,
+]);
+function normalizeAgentAttachments(input) {
+    if (!Array.isArray(input)) {
+        return [];
+    }
+    const normalized = [];
+    for (const item of input) {
+        const parsed = AgentAttachmentSchema.safeParse(item);
+        if (parsed.success) {
+            normalized.push(parsed.data);
+        }
+    }
+    return normalized;
+}
+const AgentAttachmentsSchema = z.unknown().transform(normalizeAgentAttachments).optional();
+const ImageAttachmentSchema = z.object({
+    data: z.string(), // base64 encoded image
+    mimeType: z.string(), // e.g., "image/jpeg", "image/png"
+});
+export const SendAgentMessageSchema = z.object({
+    type: z.literal("send_agent_message"),
+    agentId: z.string(),
+    text: z.string(),
+    messageId: z.string().optional(), // Client-provided ID for deduplication
+    images: z.array(ImageAttachmentSchema).optional(),
+    attachments: AgentAttachmentsSchema,
+});
+// ============================================================================
+// Agent RPCs (requestId-correlated)
+// ============================================================================
+export const FetchAgentsRequestMessageSchema = z.object({
+    type: z.literal("fetch_agents_request"),
+    requestId: z.string(),
+    scope: z.enum(["active"]).optional(),
+    filter: AgentDirectoryFilterSchema.optional(),
+    sort: z
+        .array(z.object({
+        key: z.enum(["status_priority", "created_at", "updated_at", "title"]),
+        direction: z.enum(["asc", "desc"]),
+    }))
+        .optional(),
+    page: z
+        .object({
+        limit: z.number().int().positive().max(200),
+        cursor: z.string().min(1).optional(),
+    })
+        .optional(),
+    subscribe: z
+        .object({
+        subscriptionId: z.string().optional(),
+    })
+        .optional(),
+});
+const WorkspaceStateBucketSchema = z.enum([
+    "needs_input",
+    "failed",
+    "running",
+    "attention",
+    "done",
+]);
+export const FetchWorkspacesRequestMessageSchema = z.object({
+    type: z.literal("fetch_workspaces_request"),
+    requestId: z.string(),
+    filter: z
+        .object({
+        query: z.string().optional(),
+        projectId: z.string().optional(),
+        // Unused: accepted so older clients still parse, but the server does not filter on it.
+        idPrefix: z.string().optional(),
+    })
+        .optional(),
+    sort: z
+        .array(z.object({
+        key: z.enum(["status_priority", "activity_at", "name", "project_id"]),
+        direction: z.enum(["asc", "desc"]),
+    }))
+        .optional(),
+    page: z
+        .object({
+        limit: z.number().int().positive().max(200),
+        cursor: z.string().min(1).optional(),
+    })
+        .optional(),
+    subscribe: z
+        .object({
+        subscriptionId: z.string().optional(),
+    })
+        .optional(),
+});
+export const FetchAgentHistoryRequestMessageSchema = z.object({
+    type: z.literal("fetch_agent_history_request"),
+    requestId: z.string(),
+    filter: AgentDirectoryFilterSchema.optional(),
+    sort: z
+        .array(z.object({
+        key: z.enum(["status_priority", "created_at", "updated_at", "title"]),
+        direction: z.enum(["asc", "desc"]),
+    }))
+        .optional(),
+    page: z
+        .object({
+        limit: z.number().int().positive().max(200),
+        cursor: z.string().min(1).optional(),
+    })
+        .optional(),
+});
+export const FetchRecentProviderSessionsRequestMessageSchema = z.object({
+    type: z.literal("fetch_recent_provider_sessions_request"),
+    requestId: z.string(),
+    cwd: z.string().optional(),
+    providers: z.array(z.string()).optional(),
+    since: z.string().optional(),
+    limit: z.number().int().positive().max(200).optional(),
+});
+export const FetchAgentRequestMessageSchema = z.object({
+    type: z.literal("fetch_agent_request"),
+    requestId: z.string(),
+    /** Accepts full ID, unique prefix, or exact full title (server resolves). */
+    agentId: z.string(),
+});
+export const SendAgentMessageRequestSchema = z.object({
+    type: z.literal("send_agent_message_request"),
+    requestId: z.string(),
+    /** Accepts full ID, unique prefix, or exact full title (server resolves). */
+    agentId: z.string(),
+    text: z.string(),
+    messageId: z.string().optional(), // Client-provided ID for deduplication
+    images: z.array(ImageAttachmentSchema).optional(),
+    attachments: AgentAttachmentsSchema,
+});
+export const WaitForFinishRequestSchema = z.object({
+    type: z.literal("wait_for_finish_request"),
+    requestId: z.string(),
+    /** Accepts full ID, unique prefix, or exact full title (server resolves). */
+    agentId: z.string(),
+    timeoutMs: z.number().int().positive().optional(),
+});
+export const DaemonGetStatusRequestSchema = z.object({
+    type: z.literal("daemon.get_status.request"),
+    requestId: z.string(),
+});
+export const DaemonGetPairingOfferRequestSchema = z.object({
+    type: z.literal("daemon.get_pairing_offer.request"),
+    requestId: z.string(),
+});
+export const DiagnosticsRequestSchema = z.object({
+    type: z.literal("diagnostics.request"),
+    requestId: z.string(),
+});
+export const GetDaemonConfigRequestMessageSchema = z.object({
+    type: z.literal("get_daemon_config_request"),
+    requestId: z.string(),
+});
+export const SetDaemonConfigRequestMessageSchema = z.object({
+    type: z.literal("set_daemon_config_request"),
+    requestId: z.string(),
+    config: MutableDaemonConfigPatchSchema,
+});
+export const SpeechSettingsGetOptionsRequestSchema = z.object({
+    type: z.literal("speech.settings.get_options.request"),
+    requestId: z.string(),
+});
+// One-shot "read this text aloud with this voice" for the voice-preview button.
+// The voice binding is soft, matching personality-voice semantics: an
+// unavailable voice degrades to the host default at synthesis time, and an
+// absent voice uses the host default. Synthesis runs on the host's active TTS
+// provider (there is no per-request provider switch); model/provider are hints.
+export const SpeechTtsPreviewRequestSchema = z.object({
+    type: z.literal("speech.tts.preview.request"),
+    requestId: z.string(),
+    text: z.string(),
+    voice: z
+        .object({
+        provider: z.string().optional(),
+        model: z.string().optional(),
+        name: z.string(),
+    })
+        .passthrough()
+        .optional(),
+});
+export const AgentPersonalitiesGetStatsRequestSchema = z.object({
+    type: z.literal("agentPersonalities.get_stats.request"),
+    requestId: z.string(),
+});
+export const ReadProjectConfigRequestMessageSchema = z.object({
+    type: z.literal("read_project_config_request"),
+    requestId: z.string(),
+    repoRoot: z.string(),
+});
+export const WriteProjectConfigRequestMessageSchema = z.object({
+    type: z.literal("write_project_config_request"),
+    requestId: z.string(),
+    repoRoot: z.string(),
+    config: OttoConfigRawSchema,
+    expectedRevision: OttoConfigRevisionSchema.nullable(),
+});
+// ============================================================================
+// Dictation Streaming (lossless, resumable)
+// ============================================================================
+export const DictationStreamStartMessageSchema = z.object({
+    type: z.literal("dictation_stream_start"),
+    dictationId: z.string(),
+    format: z.string(), // e.g. "audio/pcm;rate=16000;bits=16"
+});
+export const DictationStreamChunkMessageSchema = z.object({
+    type: z.literal("dictation_stream_chunk"),
+    dictationId: z.string(),
+    seq: z.number().int().nonnegative(),
+    audio: z.string(), // base64 encoded chunk
+    format: z.string(), // e.g. "audio/pcm;rate=16000;bits=16"
+});
+export const DictationStreamFinishMessageSchema = z.object({
+    type: z.literal("dictation_stream_finish"),
+    dictationId: z.string(),
+    finalSeq: z.number().int().nonnegative(),
+});
+export const DictationStreamCancelMessageSchema = z.object({
+    type: z.literal("dictation_stream_cancel"),
+    dictationId: z.string(),
+});
+const GitSetupOptionsSchema = z.object({
+    baseBranch: z.string().optional(),
+    createNewBranch: z.boolean().optional(),
+    newBranchName: z.string().optional(),
+    createWorktree: z.boolean().optional(),
+    worktreeSlug: z.string().optional(),
+    refName: z.string().min(1).optional(),
+    action: z.enum(["branch-off", "checkout"]).optional(),
+    githubPrNumber: z.number().int().positive().optional(),
+});
+export const CreateAgentWorktreeTargetSchema = z.discriminatedUnion("mode", [
+    z.object({
+        mode: z.literal("branch-off"),
+        newBranch: z.string().min(1),
+        base: z.string().min(1).optional(),
+    }),
+    z.object({
+        mode: z.literal("checkout-branch"),
+        branch: z.string().min(1),
+    }),
+    z.object({
+        mode: z.literal("checkout-pr"),
+        prNumber: z.number().int().positive(),
+    }),
+]);
+export const CreateAgentRequestMessageSchema = z.object({
+    type: z.literal("create_agent_request"),
+    config: AgentSessionConfigSchema,
+    // Optional personality id. When present the daemon resolves the personality
+    // against this cwd's provider snapshot and snapshots its identity (spinner,
+    // voice, prompt) onto the agent — the brain (provider/model/mode/effort) still
+    // comes from `config`, so hand-deviations in the picker keep the identity.
+    // COMPAT(agentPersonalities): added in v0.5.0; gate lives in features.agentPersonalities.
+    personality: z.string().optional(),
+    env: z.record(z.string(), z.string()).optional(),
+    workspaceId: z.string().optional(),
+    worktreeName: z.string().optional(),
+    initialPrompt: z.string().optional(),
+    clientMessageId: z.string().optional(),
+    outputSchema: z.record(z.string(), z.unknown()).optional(),
+    images: z.array(ImageAttachmentSchema).optional(),
+    attachments: AgentAttachmentsSchema,
+    git: GitSetupOptionsSchema.optional(),
+    worktree: CreateAgentWorktreeTargetSchema.optional(),
+    autoArchive: z.boolean().optional(),
+    labels: z.record(z.string(), z.string()).default({}),
+    requestId: z.string(),
+});
+export const ListProviderModelsRequestMessageSchema = z.object({
+    type: z.literal("list_provider_models_request"),
+    provider: AgentProviderSchema,
+    cwd: z.string().optional(),
+    requestId: z.string(),
+});
+export const ListProviderModesRequestMessageSchema = z.object({
+    type: z.literal("list_provider_modes_request"),
+    provider: AgentProviderSchema,
+    cwd: z.string().optional(),
+    requestId: z.string(),
+});
+export const ListAvailableProvidersRequestMessageSchema = z.object({
+    type: z.literal("list_available_providers_request"),
+    requestId: z.string(),
+});
+export const GetProvidersSnapshotRequestMessageSchema = z.object({
+    type: z.literal("get_providers_snapshot_request"),
+    cwd: z.string().optional(),
+    requestId: z.string(),
+});
+export const RefreshProvidersSnapshotRequestMessageSchema = z.object({
+    type: z.literal("refresh_providers_snapshot_request"),
+    cwd: z.string().optional(),
+    providers: z.array(AgentProviderSchema).optional(),
+    requestId: z.string(),
+});
+export const ProviderDiagnosticRequestMessageSchema = z.object({
+    type: z.literal("provider_diagnostic_request"),
+    provider: AgentProviderSchema,
+    requestId: z.string(),
+});
+export const ProviderUsageListRequestMessageSchema = z.object({
+    type: z.literal("provider.usage.list.request"),
+    requestId: z.string(),
+});
+export const AgentContextGetUsageRequestMessageSchema = z.object({
+    type: z.literal("agent.context.get_usage.request"),
+    agentId: z.string(),
+    requestId: z.string(),
+});
+export const ResumeAgentRequestMessageSchema = z.object({
+    type: z.literal("resume_agent_request"),
+    handle: AgentPersistenceHandleSchema,
+    overrides: AgentSessionConfigSchema.partial().optional(),
+    requestId: z.string(),
+});
+export const ImportAgentRequestMessageSchema = z.object({
+    type: z.literal("import_agent_request"),
+    provider: AgentProviderSchema.optional(),
+    providerId: z.string().optional(),
+    sessionId: z.string().optional(),
+    providerHandleId: z.string().optional(),
+    cwd: z.string().optional(),
+    labels: z.record(z.string(), z.string()).optional(),
+    requestId: z.string(),
+});
+export const RefreshAgentRequestMessageSchema = z.object({
+    type: z.literal("refresh_agent_request"),
+    agentId: z.string(),
+    requestId: z.string(),
+});
+export const CancelAgentRequestMessageSchema = z.object({
+    type: z.literal("cancel_agent_request"),
+    agentId: z.string(),
+    requestId: z.string().optional(),
+});
+export const RestartServerRequestMessageSchema = z.object({
+    type: z.literal("restart_server_request"),
+    reason: z.string().optional(),
+    requestId: z.string(),
+});
+export const ShutdownServerRequestMessageSchema = z.object({
+    type: z.literal("shutdown_server_request"),
+    requestId: z.string(),
+});
+export const DaemonUpdateRequestMessageSchema = z.object({
+    type: z.literal("daemon.update.request"),
+    requestId: z.string(),
+});
+export const AgentTimelineCursorSchema = z.object({
+    epoch: z.string(),
+    seq: z.number().int().nonnegative(),
+});
+export const FetchAgentTimelineRequestMessageSchema = z.object({
+    type: z.literal("fetch_agent_timeline_request"),
+    agentId: z.string(),
+    requestId: z.string(),
+    direction: z.enum(["tail", "before", "after"]).optional(),
+    cursor: AgentTimelineCursorSchema.optional(),
+    // 0 means "all matching rows for this query window".
+    limit: z.number().int().nonnegative().optional(),
+    // Default should be projected for app timeline loading.
+    projection: z.enum(["projected", "canonical"]).optional(),
+});
+export const AgentForkContextRequestMessageSchema = z.object({
+    type: z.literal("agent.fork_context.request"),
+    agentId: z.string(),
+    boundaryMessageId: z.string().optional(),
+    requestId: z.string(),
+});
+export const SetAgentModeRequestMessageSchema = z.object({
+    type: z.literal("set_agent_mode_request"),
+    agentId: z.string(),
+    modeId: z.string(),
+    requestId: z.string(),
+});
+const AgentActionResponsePayloadSchema = z.object({
+    requestId: z.string(),
+    agentId: z.string(),
+    accepted: z.boolean(),
+    error: z.string().nullable(),
+    notice: AgentProviderNoticeSchema.nullable().optional(),
+});
+export const SetAgentModeResponseMessageSchema = z.object({
+    type: z.literal("set_agent_mode_response"),
+    payload: AgentActionResponsePayloadSchema,
+});
+export const SetAgentModelRequestMessageSchema = z.object({
+    type: z.literal("set_agent_model_request"),
+    agentId: z.string(),
+    modelId: z.string().nullable(),
+    requestId: z.string(),
+});
+export const SetAgentModelResponseMessageSchema = z.object({
+    type: z.literal("set_agent_model_response"),
+    payload: AgentActionResponsePayloadSchema,
+});
+export const SetAgentThinkingRequestMessageSchema = z.object({
+    type: z.literal("set_agent_thinking_request"),
+    agentId: z.string(),
+    thinkingOptionId: z.string().nullable(),
+    requestId: z.string(),
+});
+export const SetAgentThinkingResponseMessageSchema = z.object({
+    type: z.literal("set_agent_thinking_response"),
+    payload: AgentActionResponsePayloadSchema,
+});
+export const SetAgentFeatureRequestMessageSchema = z.object({
+    type: z.literal("set_agent_feature_request"),
+    agentId: z.string(),
+    featureId: z.string(),
+    value: z.unknown(),
+    requestId: z.string(),
+});
+export const SetAgentFeatureResponseMessageSchema = z.object({
+    type: z.literal("set_agent_feature_response"),
+    payload: AgentActionResponsePayloadSchema,
+});
+export const AgentDetachRequestMessageSchema = z.object({
+    type: z.literal("agent.detach.request"),
+    agentId: z.string(),
+    requestId: z.string(),
+});
+export const AgentDetachResponseMessageSchema = z.object({
+    type: z.literal("agent.detach.response"),
+    payload: AgentActionResponsePayloadSchema,
+});
+// Stop a running observed subagent (Claude Task / ultracode fan-out). The
+// agentId is the observed subagent's id; the daemon resolves it to the owning
+// provider session's task and calls stopTask. Only observed subagents accept
+// this. COMPAT(observedSubagents): added in v0.4.3. See projects/observed-subagents/observed-subagents.md.
+export const AgentSubagentStopRequestMessageSchema = z.object({
+    type: z.literal("agent.subagent.stop.request"),
+    agentId: z.string(),
+    requestId: z.string(),
+});
+export const AgentSubagentStopResponseMessageSchema = z.object({
+    type: z.literal("agent.subagent.stop.response"),
+    payload: AgentActionResponsePayloadSchema,
+});
+// Switch a running agent to an Agent Personality (or clear with null). The
+// daemon re-resolves the id against the roster + the agent's cwd provider
+// snapshot and applies the full personality live — system prompt, identity
+// (name/spinner), and brain (model/mode/effort) — restarting the provider query
+// so the new prompt takes effect on the next turn. Providers that cannot apply
+// a prompt mid-session reject. COMPAT(setAgentPersonality): added in v0.5.0;
+// gate lives in features.setAgentPersonality.
+export const AgentPersonalitySetRequestMessageSchema = z.object({
+    type: z.literal("agent.personality.set.request"),
+    agentId: z.string(),
+    personalityId: z.string().nullable(),
+    requestId: z.string(),
+});
+export const AgentPersonalitySetResponseMessageSchema = z.object({
+    type: z.literal("agent.personality.set.response"),
+    payload: AgentActionResponsePayloadSchema,
+});
+export const AgentRewindModeSchema = z.enum(["conversation", "files", "both"]);
+export const AgentRewindRequestMessageSchema = z.object({
+    type: z.literal("agent.rewind.request"),
+    agentId: z.string(),
+    messageId: z.string(),
+    mode: AgentRewindModeSchema,
+    requestId: z.string(),
+});
+export const AgentRewindResponseMessageSchema = z.object({
+    type: z.literal("agent.rewind.response"),
+    payload: z.object({
+        requestId: z.string(),
+        agentId: z.string(),
+        ok: z.boolean(),
+        error: z.string().nullable(),
+    }),
+});
+export const UpdateAgentResponseMessageSchema = z.object({
+    type: z.literal("update_agent_response"),
+    payload: AgentActionResponsePayloadSchema,
+});
+export const ProjectRenameResponsePayloadSchema = z.object({
+    requestId: z.string(),
+    projectId: z.string(),
+    accepted: z.boolean(),
+    customName: z.string().nullable(),
+    error: z.string().nullable(),
+});
+export const ProjectRenameResponseSchema = z.object({
+    type: z.literal("project.rename.response"),
+    payload: ProjectRenameResponsePayloadSchema,
+});
+export const ProjectRemoveResponsePayloadSchema = z.object({
+    requestId: z.string(),
+    projectId: z.string(),
+    accepted: z.boolean(),
+    removedWorkspaceIds: z.array(z.string()).default([]),
+    error: z.string().nullable(),
+});
+export const ProjectRemoveResponseSchema = z.object({
+    type: z.literal("project.remove.response"),
+    payload: ProjectRemoveResponsePayloadSchema,
+});
+export const WorkspaceTitleSetResponsePayloadSchema = z.object({
+    requestId: z.string(),
+    workspaceId: z.string(),
+    accepted: z.boolean(),
+    title: z.string().nullable(),
+    error: z.string().nullable(),
+});
+export const WorkspaceTitleSetResponseSchema = z.object({
+    type: z.literal("workspace.title.set.response"),
+    payload: WorkspaceTitleSetResponsePayloadSchema,
+});
+export const SetVoiceModeResponseMessageSchema = z.object({
+    type: z.literal("set_voice_mode_response"),
+    payload: z.object({
+        requestId: z.string(),
+        enabled: z.boolean(),
+        agentId: z.string().nullable(),
+        accepted: z.boolean(),
+        error: z.string().nullable(),
+        reasonCode: z.string().optional(),
+        retryable: z.boolean().optional(),
+        missingModelIds: z.array(z.string()).optional(),
+    }),
+});
+export const AgentPermissionResponseMessageSchema = z.object({
+    type: z.literal("agent_permission_response"),
+    agentId: z.string(),
+    requestId: z.string(),
+    response: AgentPermissionResponseSchema,
+});
+const CheckoutErrorCodeSchema = z.enum([
+    "NOT_GIT_REPO",
+    "NOT_ALLOWED",
+    "MERGE_CONFLICT",
+    "UNKNOWN",
+]);
+const CheckoutErrorSchema = z.object({
+    code: CheckoutErrorCodeSchema,
+    message: z.string(),
+});
+const CheckoutDiffCompareSchema = z.object({
+    mode: z.enum(["uncommitted", "base"]),
+    baseRef: z.string().optional(),
+    ignoreWhitespace: z.boolean().optional(),
+});
+export const CheckoutStatusRequestSchema = z.object({
+    type: z.literal("checkout_status_request"),
+    cwd: z.string(),
+    requestId: z.string(),
+});
+export const SubscribeCheckoutDiffRequestSchema = z.object({
+    type: z.literal("subscribe_checkout_diff_request"),
+    subscriptionId: z.string(),
+    cwd: z.string(),
+    compare: CheckoutDiffCompareSchema,
+    requestId: z.string(),
+});
+export const UnsubscribeCheckoutDiffRequestSchema = z.object({
+    type: z.literal("unsubscribe_checkout_diff_request"),
+    subscriptionId: z.string(),
+});
+export const CheckoutCommitRequestSchema = z.object({
+    type: z.literal("checkout_commit_request"),
+    cwd: z.string(),
+    message: z.string().optional(),
+    addAll: z.boolean().optional(),
+    requestId: z.string(),
+});
+export const CheckoutMergeRequestSchema = z.object({
+    type: z.literal("checkout_merge_request"),
+    cwd: z.string(),
+    baseRef: z.string().optional(),
+    strategy: z.enum(["merge", "squash"]).optional(),
+    requireCleanTarget: z.boolean().optional(),
+    requestId: z.string(),
+});
+export const CheckoutMergeFromBaseRequestSchema = z.object({
+    type: z.literal("checkout_merge_from_base_request"),
+    cwd: z.string(),
+    baseRef: z.string().optional(),
+    requireCleanTarget: z.boolean().optional(),
+    requestId: z.string(),
+});
+export const CheckoutPullRequestSchema = z.object({
+    type: z.literal("checkout_pull_request"),
+    cwd: z.string(),
+    requestId: z.string(),
+});
+export const CheckoutPushRequestSchema = z.object({
+    type: z.literal("checkout_push_request"),
+    cwd: z.string(),
+    requestId: z.string(),
+});
+export const CheckoutRefreshRequestSchema = z.object({
+    type: z.literal("checkout.refresh.request"),
+    cwd: z.string(),
+    requestId: z.string(),
+});
+export const CheckoutPrCreateRequestSchema = z.object({
+    type: z.literal("checkout_pr_create_request"),
+    cwd: z.string(),
+    title: z.string().optional(),
+    body: z.string().optional(),
+    baseRef: z.string().optional(),
+    requestId: z.string(),
+});
+export const CheckoutPrMergeRequestSchema = z.object({
+    type: z.literal("checkout_pr_merge_request"),
+    cwd: z.string(),
+    mergeMethod: z.enum(["merge", "squash", "rebase"]),
+    requestId: z.string(),
+});
+export const CheckoutGithubSetAutoMergeRequestSchema = z.object({
+    type: z.literal("checkout.github.set_auto_merge.request"),
+    cwd: z.string(),
+    enabled: z.boolean(),
+    mergeMethod: z.enum(["merge", "squash", "rebase"]).optional(),
+    requestId: z.string(),
+});
+const GitHubRepoSegmentSchema = z.string().regex(/^[A-Za-z0-9._-]+$/);
+export const CheckoutGithubGetCheckDetailsRequestSchema = z.object({
+    type: z.literal("checkout.github.get_check_details.request"),
+    cwd: z.string(),
+    repoOwner: GitHubRepoSegmentSchema,
+    repoName: GitHubRepoSegmentSchema,
+    checkRunId: z.number().int().positive(),
+    workflowRunId: z.number().int().positive().optional(),
+    requestId: z.string(),
+});
+export const CheckoutPrStatusRequestSchema = z.object({
+    type: z.literal("checkout_pr_status_request"),
+    cwd: z.string(),
+    requestId: z.string(),
+});
+/**
+ * UI-initiated preview RPCs (the Preview toolbar button), distinct from the
+ * agent-facing preview_* tools in packages/server/src/server/preview/preview-tools.ts.
+ * Both sides drive the same DevServerManager; only the caller differs.
+ */
+export const PreviewListConfigRequestSchema = z.object({
+    type: z.literal("preview.list_config.request"),
+    cwd: z.string(),
+    requestId: z.string(),
+});
+export const PreviewStartRequestSchema = z.object({
+    type: z.literal("preview.start.request"),
+    cwd: z.string(),
+    name: z.string(),
+    requestId: z.string(),
+});
+export const PreviewBindTabRequestSchema = z.object({
+    type: z.literal("preview.bind_tab.request"),
+    serverId: z.string(),
+    browserId: z.string(),
+    requestId: z.string(),
+});
+export const PreviewStopRequestSchema = z.object({
+    type: z.literal("preview.stop.request"),
+    serverId: z.string(),
+    requestId: z.string(),
+});
+export const PullRequestTimelineRequestSchema = z.object({
+    type: z.literal("pull_request_timeline_request"),
+    cwd: z.string(),
+    prNumber: z.number(),
+    repoOwner: z.string(),
+    repoName: z.string(),
+    requestId: z.string(),
+});
+export const ValidateBranchRequestSchema = z.object({
+    type: z.literal("validate_branch_request"),
+    cwd: z.string(),
+    branchName: z.string(),
+    requestId: z.string(),
+});
+export const CheckoutSwitchBranchRequestSchema = z.object({
+    type: z.literal("checkout_switch_branch_request"),
+    cwd: z.string(),
+    branch: z.string(),
+    requestId: z.string(),
+});
+export const CheckoutRenameBranchRequestSchema = z.object({
+    type: z.literal("checkout.rename_branch.request"),
+    cwd: z.string(),
+    branch: z.string(),
+    requestId: z.string(),
+});
+export const StashSaveRequestSchema = z.object({
+    type: z.literal("stash_save_request"),
+    cwd: z.string(),
+    /** Branch name to tag the stash with for later identification. */
+    branch: z.string().optional(),
+    requestId: z.string(),
+});
+export const StashPopRequestSchema = z.object({
+    type: z.literal("stash_pop_request"),
+    cwd: z.string(),
+    /** Zero-based index from stash_list_response. */
+    stashIndex: z.number().int().min(0),
+    requestId: z.string(),
+});
+export const StashListRequestSchema = z.object({
+    type: z.literal("stash_list_request"),
+    cwd: z.string(),
+    /** If true, only return otto-created stashes. Default true. */
+    ottoOnly: z.boolean().optional(),
+    requestId: z.string(),
+});
+export const BranchSuggestionsRequestSchema = z.object({
+    type: z.literal("branch_suggestions_request"),
+    cwd: z.string(),
+    query: z.string().optional(),
+    limit: z.number().int().min(1).max(200).optional(),
+    requestId: z.string(),
+});
+export const GitHubSearchItemSchema = z.object({
+    kind: z.enum(["issue", "pr"]),
+    number: z.number(),
+    title: z.string(),
+    url: z.string(),
+    state: z.string(),
+    body: z.string().nullable(),
+    labels: z.array(z.string()),
+    baseRefName: z.string().nullable().optional(),
+    headRefName: z.string().nullable().optional(),
+    updatedAt: z.string().optional(),
+});
+export const GitHubSearchKindSchema = z.enum(["github-issue", "github-pr"]);
+export const GitHubSearchRequestSchema = z.object({
+    type: z.literal("github_search_request"),
+    cwd: z.string(),
+    query: z.string(),
+    limit: z.number().int().min(1).max(50).optional(),
+    kinds: z.array(GitHubSearchKindSchema).optional(),
+    requestId: z.string(),
+});
+// Provider-neutral successor to github_search_request. Resolves the project's
+// configured hosting provider from cwd. Gated by server_info
+// features.gitHostingProviders.
+export const HostingSearchKindSchema = z.enum(["issue", "pr"]);
+export const HostingSearchRequestSchema = z.object({
+    type: z.literal("hosting.search.request"),
+    cwd: z.string(),
+    query: z.string(),
+    limit: z.number().int().min(1).max(50).optional(),
+    kinds: z.array(HostingSearchKindSchema).optional(),
+    requestId: z.string(),
+});
+// Reports whether a host-level provider's credentials are valid — drives the
+// connection-status row in the host Git providers settings section.
+export const HostingAuthStatusRequestSchema = z.object({
+    type: z.literal("hosting.auth_status.request"),
+    provider: GitHostingProviderIdWireSchema,
+    requestId: z.string(),
+});
+export const DirectorySuggestionsRequestSchema = z.object({
+    type: z.literal("directory_suggestions_request"),
+    query: z.string(),
+    cwd: z.string().optional(),
+    includeFiles: z.boolean().optional(),
+    includeDirectories: z.boolean().optional(),
+    matchMode: z.enum(["fuzzy", "suffix"]).optional(),
+    limit: z.number().int().min(1).max(100).optional(),
+    requestId: z.string(),
+});
+export const OttoWorktreeListRequestSchema = z.object({
+    type: z.literal("otto_worktree_list_request"),
+    cwd: z.string().optional(),
+    repoRoot: z.string().optional(),
+    requestId: z.string(),
+});
+export const OttoWorktreeArchiveRequestSchema = z.object({
+    type: z.literal("otto_worktree_archive_request"),
+    worktreePath: z.string().optional(),
+    repoRoot: z.string().optional(),
+    branchName: z.string().optional(),
+    // COMPAT(worktreeArchiveWorkspaceId): added in v0.1.97, drop the optional gate when floor >= v0.1.97.
+    // Explicit workspace record to archive. A directory can back multiple workspaces
+    // (Model B), so resolving the target by cwd alone picks the wrong record. When
+    // present the daemon archives this exact workspace; when absent it falls back to
+    // resolving by worktreePath, preferring the worktree-kind record on a cwd tie.
+    workspaceId: z.string().optional(),
+    // COMPAT(worktreeArchiveScope): added in v0.1.97, drop the gate when floor >= v0.1.97.
+    // Scope of the archive operation. "workspace" archives a single workspace record
+    // (today's default UI behavior). "worktree" archives every active workspace whose
+    // cwd resolves to the target directory, then removes the directory if it is
+    // Otto-owned. Omitted/unknown values default to "workspace" for old-client safety.
+    scope: z.enum(["workspace", "worktree"]).optional().default("workspace"),
+    // COMPAT(worktreeDiskDeletion): added in v0.1.97, ignored as of v0.1.97
+    // (disk removal derived from scope + last-reference + ownership); field
+    // retained for wire parse-compat, drop when floor >= v0.1.97.
+    deleteWorktreeFromDisk: z.boolean().optional().default(false),
+    requestId: z.string(),
+});
+export const FirstAgentContextSchema = z.object({
+    prompt: z.string().optional(),
+    attachments: AgentAttachmentsSchema,
+});
+export const CreateOttoWorktreeRequestSchema = z.object({
+    type: z.literal("create_otto_worktree_request"),
+    cwd: z.string(),
+    projectId: z.string().optional(),
+    worktreeSlug: z.string().optional(),
+    nameContext: z.string().optional(),
+    attachments: AgentAttachmentsSchema.optional(),
+    firstAgentContext: FirstAgentContextSchema.optional(),
+    refName: z.string().min(1).optional(),
+    action: z.enum(["branch-off", "checkout"]).optional(),
+    githubPrNumber: z.number().int().positive().optional(),
+    requestId: z.string(),
+});
+export const WorkspaceSetupStatusRequestSchema = z.object({
+    type: z.literal("workspace_setup_status_request"),
+    workspaceId: z.string(),
+    requestId: z.string(),
+});
+// COMPAT(desktopEditorBridge): added in v0.1.88, remove after 2026-12-03 once old clients no longer call daemon editor RPCs.
+export const LegacyListAvailableEditorsRequestSchema = z.object({
+    type: z.literal("list_available_editors_request"),
+    requestId: z.string(),
+});
+export const LegacyOpenInEditorRequestSchema = z.object({
+    type: z.literal("open_in_editor_request"),
+    path: z.string(),
+    editorId: z.string().trim().min(1),
+    mode: z.enum(["open", "reveal"]).optional(),
+    cwd: z.string().optional(),
+    requestId: z.string(),
+});
+export const OpenProjectRequestSchema = z.object({
+    type: z.literal("open_project_request"),
+    // Path used only for workspace lookup/creation. Use the returned workspace.id for all subsequent references.
+    cwd: z.string(),
+    requestId: z.string(),
+});
+export const ProjectAddRequestSchema = z.object({
+    type: z.literal("project.add.request"),
+    cwd: z.string(),
+    requestId: z.string(),
+});
+export const ArchiveWorkspaceRequestSchema = z.object({
+    type: z.literal("archive_workspace_request"),
+    workspaceId: z.string(),
+    requestId: z.string(),
+});
+// Create a new workspace record. Unlike open_project, this never deduplicates by
+// directory: it always produces a fresh workspace. The source discriminates
+// between an existing local directory and a newly created otto worktree.
+export const WorkspaceCreateRequestSchema = z.object({
+    type: z.literal("workspace.create.request"),
+    requestId: z.string(),
+    // Optional user-set title applied to the created workspace.
+    title: z.string().optional(),
+    // Optional prompt context for workspace-level name/branch generation.
+    firstAgentContext: FirstAgentContextSchema.optional(),
+    source: z.discriminatedUnion("kind", [
+        z.object({
+            kind: z.literal("directory"),
+            // Path of the existing checkout/directory to back the workspace.
+            path: z.string(),
+            projectId: z.string().optional(),
+        }),
+        z.object({
+            kind: z.literal("worktree"),
+            // The project whose repo the worktree is cut from.
+            cwd: z.string().optional(),
+            projectId: z.string().optional(),
+            action: z.enum(["branch-off", "checkout"]).optional(),
+            // Target branch name for checkout, or new branch name for branch-off.
+            refName: z.string().min(1).optional(),
+            baseBranch: z.string().optional(),
+            githubPrNumber: z.number().int().positive().optional(),
+            worktreeSlug: z.string().optional(),
+        }),
+    ]),
+});
+export const WorkspaceClearAttentionRequestSchema = z.object({
+    type: z.literal("workspace.clear_attention.request"),
+    workspaceId: z.union([z.string(), z.array(z.string())]),
+    requestId: z.string(),
+});
+// Highlighted diff token schema
+// Note: style can be a compound class name (e.g., "heading meta") from the syntax highlighter
+const HighlightTokenSchema = z.object({
+    text: z.string(),
+    style: z.string().nullable(),
+});
+const DiffLineSchema = z.object({
+    type: z.enum(["add", "remove", "context", "header"]),
+    content: z.string(),
+    tokens: z.array(HighlightTokenSchema).optional(),
+});
+const DiffHunkSchema = z.object({
+    oldStart: z.number(),
+    oldCount: z.number(),
+    newStart: z.number(),
+    newCount: z.number(),
+    lines: z.array(DiffLineSchema),
+});
+const ParsedDiffFileSchema = z.object({
+    path: z.string(),
+    isNew: z.boolean(),
+    isDeleted: z.boolean(),
+    additions: z.number(),
+    deletions: z.number(),
+    hunks: z.array(DiffHunkSchema),
+    status: z.enum(["ok", "too_large", "binary"]).optional(),
+});
+const FileExplorerEntrySchema = z.object({
+    name: z.string(),
+    path: z.string(),
+    kind: z.enum(["file", "directory"]),
+    size: z.number(),
+    modifiedAt: z.string(),
+});
+export const FileEolSchema = z.enum(["lf", "crlf"]);
+const FileExplorerFileSchema = z.object({
+    path: z.string(),
+    kind: z.enum(["text", "image", "binary"]),
+    encoding: z.enum(["utf-8", "base64", "none"]),
+    content: z.string().optional(),
+    mimeType: z.string().optional(),
+    size: z.number(),
+    modifiedAt: z.string(),
+    // COMPAT(textEditor): added in v0.4.4 for editor buffers (text files on the
+    // inline JSON read path only); old daemons omit both fields.
+    eol: FileEolSchema.optional(),
+    hash: z.string().optional(),
+});
+const FileExplorerDirectorySchema = z.object({
+    path: z.string(),
+    entries: z.array(FileExplorerEntrySchema),
+});
+export const FileExplorerRequestSchema = z.object({
+    type: z.literal("file_explorer_request"),
+    cwd: z.string(),
+    path: z.string().optional(),
+    mode: z.enum(["list", "file"]),
+    requestId: z.string(),
+    acceptBinary: z.boolean().optional(),
+});
+export const ProjectIconRequestSchema = z.object({
+    type: z.literal("project_icon_request"),
+    cwd: z.string(),
+    requestId: z.string(),
+});
+export const FileDownloadTokenRequestSchema = z.object({
+    type: z.literal("file_download_token_request"),
+    cwd: z.string(),
+    path: z.string(),
+    requestId: z.string(),
+});
+export const FileUploadRequestSchema = z.object({
+    type: z.literal("file.upload.request"),
+    fileName: z.string().min(1),
+    mimeType: z.string().min(1),
+    size: z.number().int().nonnegative(),
+    modifiedAt: z.string(),
+    requestId: z.string(),
+});
+/**
+ * Text-editor save. A conditional write: the request carries the client's
+ * last-known file identity and the daemon refuses to clobber content it did
+ * not hand out — a mismatch comes back as a typed conflict, never a write.
+ */
+export const FileWriteRequestSchema = z.object({
+    type: z.literal("file.write.request"),
+    cwd: z.string(),
+    path: z.string(),
+    // LF-normalized UTF-8 text; the daemon re-applies the file's detected EOL.
+    content: z.string(),
+    expectedModifiedAt: z.string(),
+    expectedHash: z.string().optional(),
+    // Set only by the deleted-file "save re-creates" flow; a missing target is
+    // otherwise never an invitation to create one. When the file reappeared in
+    // the meantime, the normal precondition check still applies.
+    allowCreate: z.boolean().optional(),
+    // EOL to apply when creating (there is no on-disk EOL to detect).
+    eol: FileEolSchema.optional(),
+    requestId: z.string(),
+});
+// Subscriptions exist only for paths open in tabs; the daemon cleans them up
+// when the session ends.
+export const FileWatchSubscribeRequestSchema = z.object({
+    type: z.literal("file.watch.subscribe.request"),
+    cwd: z.string(),
+    path: z.string(),
+    requestId: z.string(),
+});
+export const FileWatchUnsubscribeRequestSchema = z.object({
+    type: z.literal("file.watch.unsubscribe.request"),
+    cwd: z.string(),
+    path: z.string(),
+    requestId: z.string(),
+});
+// ctags-style navigation (no LSP). All three are daemon RPCs so the client
+// never touches the filesystem; the symbol index is name-based and honest.
+export const CodeListFilesRequestSchema = z.object({
+    type: z.literal("code.list_files.request"),
+    cwd: z.string(),
+    requestId: z.string(),
+});
+export const CodeSymbolsRequestSchema = z.object({
+    type: z.literal("code.symbols.request"),
+    cwd: z.string(),
+    name: z.string(),
+    requestId: z.string(),
+});
+export const CodeOutlineRequestSchema = z.object({
+    type: z.literal("code.outline.request"),
+    cwd: z.string(),
+    path: z.string(),
+    requestId: z.string(),
+});
+/**
+ * Project-wide search ("Find in Files" semantics: explicit search, not
+ * per-keystroke). Results stream as file.search.result events correlated by
+ * searchId (= this requestId); a new search from the same session supersedes
+ * any in-flight one.
+ */
+export const FileSearchRequestSchema = z.object({
+    type: z.literal("file.search.request"),
+    cwd: z.string(),
+    query: z.string(),
+    caseSensitive: z.boolean().optional(),
+    wholeWord: z.boolean().optional(),
+    regexp: z.boolean().optional(),
+    include: z.string().optional(),
+    exclude: z.string().optional(),
+    requestId: z.string(),
+});
+const FileReplaceMatchSchema = z.object({
+    /** 1-based line number. */
+    line: z.number().int().positive(),
+    /** 1-based character column of the match start. */
+    column: z.number().int().positive(),
+    /** Match length in characters. */
+    length: z.number().int().nonnegative(),
+});
+/**
+ * Preview-first project replace. Each file carries the hash the preview was
+ * built against — files changed since are skipped and reported, never
+ * corrupted. The replacement string is literal (no capture references in v1).
+ */
+export const FileReplaceRequestSchema = z.object({
+    type: z.literal("file.replace.request"),
+    cwd: z.string(),
+    replacement: z.string(),
+    files: z.array(z.object({
+        path: z.string(),
+        expectedHash: z.string(),
+        matches: z.array(FileReplaceMatchSchema),
+    })),
+    requestId: z.string(),
+});
+export const ClearAgentAttentionMessageSchema = z.object({
+    type: z.literal("clear_agent_attention"),
+    agentId: z.union([z.string(), z.array(z.string())]),
+    requestId: z.string().optional(),
+});
+export const ClientHeartbeatMessageSchema = z.object({
+    type: z.literal("client_heartbeat"),
+    deviceType: z.enum(["web", "mobile"]),
+    focusedAgentId: z.string().nullable(),
+    // COMPAT(terminalFocusHeartbeat): added in v0.1.97, remove optional default after 2026-12-13 once old clients no longer send heartbeats without terminal focus.
+    focusedTerminalId: z.string().nullable().optional().default(null),
+    lastActivityAt: z.string(),
+    appVisible: z.boolean(),
+    appVisibilityChangedAt: z.string().optional(),
+});
+export const PingMessageSchema = z.object({
+    type: z.literal("ping"),
+    requestId: z.string(),
+    clientSentAt: z.number().int().optional(),
+});
+const ListCommandsDraftConfigSchema = z.object({
+    provider: AgentProviderSchema,
+    cwd: z.string(),
+    modeId: z.string().optional(),
+    model: z.string().optional(),
+    thinkingOptionId: z.string().optional(),
+    featureValues: z.record(z.string(), z.unknown()).optional(),
+});
+export const ListProviderFeaturesRequestMessageSchema = z.object({
+    type: z.literal("list_provider_features_request"),
+    draftConfig: ListCommandsDraftConfigSchema,
+    requestId: z.string(),
+});
+export const ListCommandsRequestSchema = z.object({
+    type: z.literal("list_commands_request"),
+    agentId: z.string(),
+    draftConfig: ListCommandsDraftConfigSchema.optional(),
+    requestId: z.string(),
+});
+export const RegisterPushTokenMessageSchema = z.object({
+    type: z.literal("register_push_token"),
+    token: z.string(),
+});
+// ============================================================================
+// Terminal Messages
+// ============================================================================
+export const ListTerminalsRequestSchema = z.object({
+    type: z.literal("list_terminals_request"),
+    cwd: z.string().optional(),
+    workspaceId: z.string().optional(),
+    requestId: z.string(),
+});
+export const SubscribeTerminalsRequestSchema = z.object({
+    type: z.literal("subscribe_terminals_request"),
+    cwd: z.string(),
+    workspaceId: z.string().optional(),
+});
+export const UnsubscribeTerminalsRequestSchema = z.object({
+    type: z.literal("unsubscribe_terminals_request"),
+    cwd: z.string(),
+    workspaceId: z.string().optional(),
+});
+export const CreateTerminalRequestSchema = z.object({
+    type: z.literal("create_terminal_request"),
+    cwd: z.string(),
+    workspaceId: z.string().optional(),
+    name: z.string().optional(),
+    agentId: z.string().optional(),
+    command: z.string().optional(),
+    args: z.array(z.string()).optional(),
+    requestId: z.string(),
+});
+export const RenameTerminalRequestSchema = z.object({
+    type: z.literal("terminal.rename.request"),
+    terminalId: z.string(),
+    title: z.string(),
+    requestId: z.string(),
+});
+export const StartWorkspaceScriptRequestSchema = z.object({
+    type: z.literal("start_workspace_script_request"),
+    workspaceId: z.string(),
+    scriptName: z.string(),
+    requestId: z.string(),
+});
+export const SubscribeTerminalRequestSchema = z.object({
+    type: z.literal("subscribe_terminal_request"),
+    terminalId: z.string(),
+    requestId: z.string(),
+    restore: z
+        .object({
+        mode: z.enum(["live", "visible-snapshot", "full-snapshot"]),
+        scrollbackLines: z.number().int().nonnegative().optional(),
+        size: z
+            .object({
+            rows: z.number().int().positive(),
+            cols: z.number().int().positive(),
+        })
+            .optional(),
+    })
+        .optional(),
+});
+export const UnsubscribeTerminalRequestSchema = z.object({
+    type: z.literal("unsubscribe_terminal_request"),
+    terminalId: z.string(),
+});
+const TerminalClientMessageSchema = z.discriminatedUnion("type", [
+    z.object({ type: z.literal("input"), data: z.string() }),
+    z.object({ type: z.literal("resize"), rows: z.number(), cols: z.number() }),
+    z.object({
+        type: z.literal("mouse"),
+        row: z.number(),
+        col: z.number(),
+        button: z.number(),
+        action: z.enum(["down", "up", "move"]),
+    }),
+]);
+export const TerminalInputSchema = z.object({
+    type: z.literal("terminal_input"),
+    terminalId: z.string(),
+    message: TerminalClientMessageSchema,
+});
+export const KillTerminalRequestSchema = z.object({
+    type: z.literal("kill_terminal_request"),
+    terminalId: z.string(),
+    requestId: z.string(),
+});
+export const CaptureTerminalRequestSchema = z.object({
+    type: z.literal("capture_terminal_request"),
+    terminalId: z.string(),
+    start: z.number().int().optional(),
+    end: z.number().int().optional(),
+    stripAnsi: z.boolean().default(true),
+    requestId: z.string(),
+});
+export const SessionInboundMessageSchema = z.discriminatedUnion("type", [
+    BrowserAutomationExecuteResponseSchema,
+    VoiceAudioChunkMessageSchema,
+    AbortRequestMessageSchema,
+    AudioPlayedMessageSchema,
+    FetchAgentsRequestMessageSchema,
+    FetchAgentHistoryRequestMessageSchema,
+    FetchRecentProviderSessionsRequestMessageSchema,
+    FetchWorkspacesRequestMessageSchema,
+    FetchAgentRequestMessageSchema,
+    DeleteAgentRequestMessageSchema,
+    ArchiveAgentRequestMessageSchema,
+    CloseItemsRequestMessageSchema,
+    UpdateAgentRequestMessageSchema,
+    ProjectRenameRequestSchema,
+    ProjectRemoveRequestSchema,
+    WorkspaceTitleSetRequestSchema,
+    SetVoiceModeMessageSchema,
+    SendAgentMessageRequestSchema,
+    WaitForFinishRequestSchema,
+    DaemonGetStatusRequestSchema,
+    DaemonGetPairingOfferRequestSchema,
+    DiagnosticsRequestSchema,
+    GetDaemonConfigRequestMessageSchema,
+    SetDaemonConfigRequestMessageSchema,
+    SpeechSettingsGetOptionsRequestSchema,
+    SpeechTtsPreviewRequestSchema,
+    AgentPersonalitiesGetStatsRequestSchema,
+    ReadProjectConfigRequestMessageSchema,
+    WriteProjectConfigRequestMessageSchema,
+    DictationStreamStartMessageSchema,
+    DictationStreamChunkMessageSchema,
+    DictationStreamFinishMessageSchema,
+    DictationStreamCancelMessageSchema,
+    CreateAgentRequestMessageSchema,
+    ListProviderModelsRequestMessageSchema,
+    ListProviderModesRequestMessageSchema,
+    ListProviderFeaturesRequestMessageSchema,
+    ListAvailableProvidersRequestMessageSchema,
+    GetProvidersSnapshotRequestMessageSchema,
+    RefreshProvidersSnapshotRequestMessageSchema,
+    ProviderDiagnosticRequestMessageSchema,
+    ProviderUsageListRequestMessageSchema,
+    AgentContextGetUsageRequestMessageSchema,
+    ResumeAgentRequestMessageSchema,
+    ImportAgentRequestMessageSchema,
+    RefreshAgentRequestMessageSchema,
+    CancelAgentRequestMessageSchema,
+    ShutdownServerRequestMessageSchema,
+    RestartServerRequestMessageSchema,
+    DaemonUpdateRequestMessageSchema,
+    FetchAgentTimelineRequestMessageSchema,
+    AgentForkContextRequestMessageSchema,
+    SetAgentModeRequestMessageSchema,
+    SetAgentModelRequestMessageSchema,
+    SetAgentThinkingRequestMessageSchema,
+    SetAgentFeatureRequestMessageSchema,
+    AgentDetachRequestMessageSchema,
+    AgentSubagentStopRequestMessageSchema,
+    AgentPersonalitySetRequestMessageSchema,
+    AgentRewindRequestMessageSchema,
+    AgentPermissionResponseMessageSchema,
+    CheckoutStatusRequestSchema,
+    SubscribeCheckoutDiffRequestSchema,
+    UnsubscribeCheckoutDiffRequestSchema,
+    CheckoutCommitRequestSchema,
+    CheckoutMergeRequestSchema,
+    CheckoutMergeFromBaseRequestSchema,
+    CheckoutPullRequestSchema,
+    CheckoutPushRequestSchema,
+    CheckoutRefreshRequestSchema,
+    CheckoutPrCreateRequestSchema,
+    CheckoutPrMergeRequestSchema,
+    CheckoutGithubSetAutoMergeRequestSchema,
+    CheckoutGithubGetCheckDetailsRequestSchema,
+    PreviewListConfigRequestSchema,
+    PreviewStartRequestSchema,
+    PreviewBindTabRequestSchema,
+    PreviewStopRequestSchema,
+    CheckoutPrStatusRequestSchema,
+    PullRequestTimelineRequestSchema,
+    CheckoutSwitchBranchRequestSchema,
+    CheckoutRenameBranchRequestSchema,
+    StashSaveRequestSchema,
+    StashPopRequestSchema,
+    StashListRequestSchema,
+    ValidateBranchRequestSchema,
+    BranchSuggestionsRequestSchema,
+    GitHubSearchRequestSchema,
+    HostingSearchRequestSchema,
+    HostingAuthStatusRequestSchema,
+    DirectorySuggestionsRequestSchema,
+    OttoWorktreeListRequestSchema,
+    OttoWorktreeArchiveRequestSchema,
+    CreateOttoWorktreeRequestSchema,
+    WorkspaceSetupStatusRequestSchema,
+    LegacyListAvailableEditorsRequestSchema,
+    LegacyOpenInEditorRequestSchema,
+    OpenProjectRequestSchema,
+    ProjectAddRequestSchema,
+    ArchiveWorkspaceRequestSchema,
+    WorkspaceCreateRequestSchema,
+    WorkspaceClearAttentionRequestSchema,
+    FileExplorerRequestSchema,
+    ProjectIconRequestSchema,
+    FileDownloadTokenRequestSchema,
+    FileUploadRequestSchema,
+    FileWriteRequestSchema,
+    FileWatchSubscribeRequestSchema,
+    FileWatchUnsubscribeRequestSchema,
+    FileSearchRequestSchema,
+    FileReplaceRequestSchema,
+    CodeListFilesRequestSchema,
+    CodeSymbolsRequestSchema,
+    CodeOutlineRequestSchema,
+    ClearAgentAttentionMessageSchema,
+    ClientHeartbeatMessageSchema,
+    PingMessageSchema,
+    ListCommandsRequestSchema,
+    RegisterPushTokenMessageSchema,
+    ListTerminalsRequestSchema,
+    SubscribeTerminalsRequestSchema,
+    UnsubscribeTerminalsRequestSchema,
+    CreateTerminalRequestSchema,
+    RenameTerminalRequestSchema,
+    StartWorkspaceScriptRequestSchema,
+    SubscribeTerminalRequestSchema,
+    UnsubscribeTerminalRequestSchema,
+    TerminalInputSchema,
+    KillTerminalRequestSchema,
+    CaptureTerminalRequestSchema,
+    ChatCreateRequestSchema,
+    ChatListRequestSchema,
+    ChatInspectRequestSchema,
+    ChatDeleteRequestSchema,
+    ChatPostRequestSchema,
+    ChatReadRequestSchema,
+    ChatWaitRequestSchema,
+    ScheduleCreateRequestSchema,
+    ScheduleListRequestSchema,
+    ScheduleInspectRequestSchema,
+    ScheduleLogsRequestSchema,
+    SchedulePauseRequestSchema,
+    ScheduleResumeRequestSchema,
+    ScheduleDeleteRequestSchema,
+    ScheduleRunOnceRequestSchema,
+    ScheduleUpdateRequestSchema,
+    LoopRunRequestSchema,
+    LoopListRequestSchema,
+    LoopInspectRequestSchema,
+    LoopLogsRequestSchema,
+    LoopStopRequestSchema,
+    // COMPAT(artifacts): added in v0.4.1, drop the gate when daemon floor >= v0.4.1.
+    ArtifactListRequestSchema,
+    ArtifactCreateRequestSchema,
+    ArtifactUpdateRequestSchema,
+    ArtifactRegenerateRequestSchema,
+    ArtifactCancelRequestSchema,
+    ArtifactDeleteRequestSchema,
+    ArtifactStarRequestSchema,
+    ArtifactGetContentRequestSchema,
+]);
+// ============================================================================
+// Session Outbound Messages (Session emits these)
+// ============================================================================
+export const ActivityLogPayloadSchema = z.object({
+    id: z.string(),
+    timestamp: z.coerce.date(),
+    type: z.enum(["transcript", "assistant", "tool_call", "tool_result", "error", "system"]),
+    content: z.string(),
+    metadata: z.record(z.string(), z.unknown()).optional(),
+});
+export const ActivityLogMessageSchema = z.object({
+    type: z.literal("activity_log"),
+    payload: ActivityLogPayloadSchema,
+});
+export const AssistantChunkMessageSchema = z.object({
+    type: z.literal("assistant_chunk"),
+    payload: z.object({
+        chunk: z.string(),
+    }),
+});
+export const AudioOutputMessageSchema = z.object({
+    type: z.literal("audio_output"),
+    payload: z.object({
+        audio: z.string(), // base64 encoded
+        format: z.string(),
+        id: z.string(),
+        isVoiceMode: z.boolean(), // Mode when audio was generated (for drift protection)
+        groupId: z.string().optional(), // Logical utterance id
+        chunkIndex: z.number().int().nonnegative().optional(),
+        isLastChunk: z.boolean().optional(),
+    }),
+});
+export const TranscriptionResultMessageSchema = z.object({
+    type: z.literal("transcription_result"),
+    payload: z.object({
+        text: z.string(),
+        language: z.string().optional(),
+        duration: z.number().optional(),
+        requestId: z.string(), // Echoed back from request for tracking
+        avgLogprob: z.number().optional(),
+        isLowConfidence: z.boolean().optional(),
+        byteLength: z.number().optional(),
+        format: z.string().optional(),
+        debugRecordingPath: z.string().optional(),
+    }),
+});
+export const VoiceInputStateMessageSchema = z.object({
+    type: z.literal("voice_input_state"),
+    payload: z.object({
+        isSpeaking: z.boolean(),
+    }),
+});
+export const DictationStreamAckMessageSchema = z.object({
+    type: z.literal("dictation_stream_ack"),
+    payload: z.object({
+        dictationId: z.string(),
+        ackSeq: z.number().int(),
+    }),
+});
+export const DictationStreamFinishAcceptedMessageSchema = z.object({
+    type: z.literal("dictation_stream_finish_accepted"),
+    payload: z.object({
+        dictationId: z.string(),
+        timeoutMs: z.number().int().positive(),
+    }),
+});
+export const DictationStreamPartialMessageSchema = z.object({
+    type: z.literal("dictation_stream_partial"),
+    payload: z.object({
+        dictationId: z.string(),
+        text: z.string(),
+    }),
+});
+export const DictationStreamFinalMessageSchema = z.object({
+    type: z.literal("dictation_stream_final"),
+    payload: z.object({
+        dictationId: z.string(),
+        text: z.string(),
+        debugRecordingPath: z.string().optional(),
+    }),
+});
+export const DictationStreamErrorMessageSchema = z.object({
+    type: z.literal("dictation_stream_error"),
+    payload: z.object({
+        dictationId: z.string(),
+        error: z.string(),
+        retryable: z.boolean(),
+        reasonCode: z.string().optional(),
+        missingModelIds: z.array(z.string()).optional(),
+        debugRecordingPath: z.string().optional(),
+    }),
+});
+export const ServerCapabilityStateSchema = z.object({
+    enabled: z.boolean(),
+    reason: z.string(),
+});
+export const ServerVoiceCapabilitiesSchema = z.object({
+    dictation: ServerCapabilityStateSchema,
+    voice: ServerCapabilityStateSchema,
+});
+export const ServerCapabilitiesSchema = z
+    .object({
+    voice: ServerVoiceCapabilitiesSchema.optional(),
+})
+    .passthrough();
+const ServerInfoHostnameSchema = z.unknown().transform((value) => {
+    if (typeof value !== "string") {
+        return null;
+    }
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : null;
+});
+const ServerInfoVersionSchema = z.unknown().transform((value) => {
+    if (typeof value !== "string") {
+        return null;
+    }
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : null;
+});
+const ServerCapabilitiesFromUnknownSchema = z
+    .unknown()
+    .optional()
+    .transform((value) => {
+    if (value === undefined) {
+        return undefined;
+    }
+    const parsed = ServerCapabilitiesSchema.safeParse(value);
+    if (!parsed.success) {
+        return undefined;
+    }
+    return parsed.data;
+});
+export const ServerInfoStatusPayloadSchema = z
+    .object({
+    status: z.literal("server_info"),
+    serverId: z.string().trim().min(1),
+    hostname: ServerInfoHostnameSchema.optional(),
+    version: ServerInfoVersionSchema.optional(),
+    capabilities: ServerCapabilitiesFromUnknownSchema.optional(),
+    // COMPAT(providersSnapshot): added in v0.1.48, remove gating when all clients use snapshot
+    features: z
+        .object({
+        providersSnapshot: z.boolean().optional(),
+        checkoutGithubSetAutoMerge: z.boolean().optional(),
+        // COMPAT(githubCheckDetails): added in v0.1.92, remove gate after 2026-12-08.
+        githubCheckDetails: z.boolean().optional(),
+        // COMPAT(daemonStatusRpc): added in v0.1.76, remove gate after 2026-11-18.
+        daemonStatusRpc: z.boolean().optional(),
+        // COMPAT(terminalRestoreModes): added in v0.1.81, remove gate after 2026-11-23.
+        "terminal-restore-modes": z.boolean().optional(),
+        // COMPAT(rewind): added in v0.1.X, drop the gate when floor >= v0.1.X.
+        rewind: z.boolean().optional(),
+        // COMPAT(checkoutRefresh): added in v0.1.86, remove gate after 2026-11-29.
+        checkoutRefresh: z.boolean().optional(),
+        // COMPAT(workspaceMultiplicity): added in v0.1.97, drop the gate when floor >= v0.1.97
+        workspaceMultiplicity: z.boolean().optional(),
+        // COMPAT(projectRemove): added in v0.1.97, drop the gate when floor >= v0.1.97.
+        projectRemove: z.boolean().optional(),
+        // COMPAT(projectAdd): added in v0.1.97, drop the gate when floor >= v0.1.97.
+        projectAdd: z.boolean().optional(),
+        // COMPAT(worktreeRestore): added in v0.1.97, drop the gate when floor >= v0.1.97
+        worktreeRestore: z.boolean().optional(),
+        // COMPAT(providerUsageList): added in v0.1.98, drop the gate when daemon floor >= v0.1.98.
+        providerUsageList: z.boolean().optional(),
+        // COMPAT(agentDetach): added in v0.1.98, remove gate after 2026-12-19 once daemon floor >= v0.1.98.
+        agentDetach: z.boolean().optional(),
+        // COMPAT(daemonDiagnostics): added in v0.1.100, remove gate after 2026-12-25 once daemon floor >= v0.1.100.
+        daemonDiagnostics: z.boolean().optional(),
+        // COMPAT(daemonSelfUpdate): added in v0.1.93, remove gate after 2026-12-13.
+        daemonSelfUpdate: z.boolean().optional(),
+        // COMPAT(agentForkContext): added in v0.1.102, remove gate after 2026-12-28.
+        agentForkContext: z.boolean().optional(),
+        // COMPAT(providerRemove): added in v0.1.105, drop the gate when daemon floor >= v0.1.105.
+        providerRemove: z.boolean().optional(),
+        // COMPAT(agentContextUsage): added in v0.3.4, drop the gate when daemon floor >= v0.3.4.
+        agentContextUsage: z.boolean().optional(),
+        // COMPAT(artifacts): added in v0.4.1, drop the gate when daemon floor >= v0.4.1.
+        artifacts: z.boolean().optional(),
+        // COMPAT(observedSubagents): added in v0.4.3, drop the gate when daemon floor >= v0.4.3.
+        observedSubagents: z.boolean().optional(),
+        // COMPAT(textEditor): added in v0.4.4, drop the gate when daemon floor >= v0.4.4.
+        textEditor: z.boolean().optional(),
+        // COMPAT(projectSearch): added in v0.4.4, drop the gate when daemon floor >= v0.4.4.
+        projectSearch: z.boolean().optional(),
+        // COMPAT(codeIndex): added in v0.4.4, drop the gate when daemon floor >= v0.4.4.
+        codeIndex: z.boolean().optional(),
+        // COMPAT(artifactsToolGroup): added in v0.4.5, drop the gate when daemon floor >= v0.4.5.
+        artifactsToolGroup: z.boolean().optional(),
+        // COMPAT(speechSettings): added in v0.4.5, drop the gate when daemon floor >= v0.4.5.
+        speechSettings: z.boolean().optional(),
+        // COMPAT(gitHostingProviders): added in v0.4.5, drop the gate when daemon floor >= v0.4.5.
+        gitHostingProviders: z.boolean().optional(),
+        // COMPAT(agentPersonalities): added in v0.5.0, drop the gate when daemon floor >= v0.5.0.
+        agentPersonalities: z.boolean().optional(),
+        // COMPAT(ttsPreview): added in v0.4.7, drop the gate when daemon floor >= v0.4.7.
+        ttsPreview: z.boolean().optional(),
+        // COMPAT(setAgentPersonality): added in v0.5.0, drop the gate when daemon floor >= v0.5.0.
+        setAgentPersonality: z.boolean().optional(),
+    })
+        .optional(),
+})
+    .passthrough()
+    .transform((payload) => ({
+    ...payload,
+    hostname: payload.hostname ?? null,
+    version: payload.version ?? null,
+}));
+export const StatusMessageSchema = z.object({
+    type: z.literal("status"),
+    payload: z
+        .object({
+        status: z.string(),
+    })
+        .passthrough(), // Allow additional fields
+});
+export const PongMessageSchema = z.object({
+    type: z.literal("pong"),
+    payload: z.object({
+        requestId: z.string(),
+        clientSentAt: z.number().int().optional(),
+        serverReceivedAt: z.number().int(),
+        serverSentAt: z.number().int(),
+    }),
+});
+export const RpcErrorMessageSchema = z.object({
+    type: z.literal("rpc_error"),
+    payload: z.object({
+        requestId: z.string(),
+        requestType: z.string().optional(),
+        error: z.string(),
+        code: z.string().optional(),
+    }),
+});
+const AgentStatusWithRequestSchema = z.object({
+    agentId: z.string(),
+    requestId: z.string(),
+});
+const AgentStatusWithTimelineSchema = AgentStatusWithRequestSchema.extend({
+    timelineSize: z.number().optional(),
+});
+export const AgentCreatedStatusPayloadSchema = z
+    .object({
+    status: z.literal("agent_created"),
+    agent: AgentSnapshotPayloadSchema,
+})
+    .extend(AgentStatusWithRequestSchema.shape);
+export const AgentCreateFailedStatusPayloadSchema = z.object({
+    status: z.literal("agent_create_failed"),
+    requestId: z.string(),
+    error: z.string(),
+    errorCode: z.string().optional(),
+});
+export const AgentResumedStatusPayloadSchema = z
+    .object({
+    status: z.literal("agent_resumed"),
+    agent: AgentSnapshotPayloadSchema,
+})
+    .extend(AgentStatusWithTimelineSchema.shape);
+export const AgentRefreshedStatusPayloadSchema = z
+    .object({
+    status: z.literal("agent_refreshed"),
+})
+    .extend(AgentStatusWithTimelineSchema.shape);
+export const RestartRequestedStatusPayloadSchema = z.object({
+    status: z.literal("restart_requested"),
+    clientId: z.string(),
+    reason: z.string().optional(),
+    requestId: z.string(),
+});
+export const ShutdownRequestedStatusPayloadSchema = z.object({
+    status: z.literal("shutdown_requested"),
+    clientId: z.string(),
+    requestId: z.string(),
+});
+export const DaemonConfigChangedStatusPayloadSchema = z
+    .object({
+    status: z.literal("daemon_config_changed"),
+    config: MutableDaemonConfigSchema,
+})
+    .passthrough();
+export const KnownStatusPayloadSchema = z.discriminatedUnion("status", [
+    AgentCreatedStatusPayloadSchema,
+    AgentCreateFailedStatusPayloadSchema,
+    AgentResumedStatusPayloadSchema,
+    AgentRefreshedStatusPayloadSchema,
+    ShutdownRequestedStatusPayloadSchema,
+    RestartRequestedStatusPayloadSchema,
+    DaemonConfigChangedStatusPayloadSchema,
+]);
+export const ArtifactMessageSchema = z.object({
+    type: z.literal("artifact"),
+    payload: z.object({
+        type: z.enum(["markdown", "diff", "image", "code"]),
+        id: z.string(),
+        title: z.string(),
+        content: z.string(),
+        isBase64: z.boolean(),
+    }),
+});
+export const ProjectCheckoutLiteNotGitPayloadSchema = z
+    .object({
+    cwd: z.string(),
+    isGit: z.literal(false),
+    currentBranch: z.null(),
+    remoteUrl: z.null(),
+    worktreeRoot: z.null().optional(),
+    isOttoOwnedWorktree: z.literal(false),
+    mainRepoRoot: z.null(),
+})
+    .transform((value) => ({
+    ...value,
+    worktreeRoot: null,
+}));
+export const ProjectCheckoutLiteGitNonOttoPayloadSchema = z
+    .object({
+    cwd: z.string(),
+    isGit: z.literal(true),
+    currentBranch: z.string().nullable(),
+    remoteUrl: z.string().nullable(),
+    worktreeRoot: z.string().optional(),
+    isOttoOwnedWorktree: z.literal(false),
+    mainRepoRoot: z.string().nullable().optional().default(null),
+})
+    .transform((value) => ({
+    ...value,
+    worktreeRoot: value.worktreeRoot ?? value.cwd,
+}));
+export const ProjectCheckoutLiteGitOttoPayloadSchema = z
+    .object({
+    cwd: z.string(),
+    isGit: z.literal(true),
+    currentBranch: z.string().nullable(),
+    remoteUrl: z.string().nullable(),
+    worktreeRoot: z.string().optional(),
+    isOttoOwnedWorktree: z.literal(true),
+    mainRepoRoot: z.string(),
+})
+    .transform((value) => ({
+    ...value,
+    worktreeRoot: value.worktreeRoot ?? value.cwd,
+}));
+export const ProjectCheckoutLitePayloadSchema = z.union([
+    ProjectCheckoutLiteNotGitPayloadSchema,
+    ProjectCheckoutLiteGitNonOttoPayloadSchema,
+    ProjectCheckoutLiteGitOttoPayloadSchema,
+]);
+export const ProjectPlacementPayloadSchema = z.object({
+    projectKey: z.string(),
+    projectName: z.string(),
+    workspaceName: z.string().nullable().optional(),
+    checkout: ProjectCheckoutLitePayloadSchema,
+});
+export const WorkspaceScriptLifecycleSchema = z.enum(["running", "stopped"]);
+export const WorkspaceScriptHealthSchema = z.enum(["healthy", "unhealthy"]);
+export const WorkspaceScriptPayloadSchema = z.object({
+    scriptName: z.string(),
+    type: z.enum(["script", "service"]).optional().default("service"),
+    hostname: z.string(),
+    port: z.number().int().positive().nullable(),
+    localProxyUrl: z.string().nullable().optional(),
+    publicProxyUrl: z.string().nullable().optional(),
+    proxyUrl: z.string().nullable().optional().default(null),
+    lifecycle: WorkspaceScriptLifecycleSchema,
+    health: WorkspaceScriptHealthSchema.nullable(),
+    exitCode: z.number().nullable().optional().default(null),
+    terminalId: z.string().nullable().optional().default(null),
+});
+const WorkspaceGitRuntimePayloadSchema = z
+    .object({
+    currentBranch: z.string().nullable().optional(),
+    remoteUrl: z.string().nullable().optional(),
+    isOttoOwnedWorktree: z.boolean().optional(),
+    isDirty: z.boolean().nullable().optional(),
+    aheadBehind: z
+        .object({
+        ahead: z.number(),
+        behind: z.number(),
+    })
+        .nullable()
+        .optional(),
+    aheadOfOrigin: z.number().nullable().optional(),
+    behindOfOrigin: z.number().nullable().optional(),
+})
+    .optional()
+    .nullable();
+const WorkspaceGitHubRuntimePayloadSchema = z
+    .object({
+    featuresEnabled: z.boolean().optional(),
+    pullRequest: z
+        .object({
+        number: z.number().optional(),
+        url: z.string(),
+        title: z.string(),
+        state: z.string(),
+        baseRefName: z.string(),
+        headRefName: z.string(),
+        isMerged: z.boolean(),
+        isDraft: z.boolean().optional(),
+        mergeable: z.enum(["MERGEABLE", "CONFLICTING", "UNKNOWN"]).catch("UNKNOWN").optional(),
+        checks: z
+            .array(z.object({
+            name: z.string(),
+            status: z.enum(["success", "failure", "pending", "skipped", "cancelled"]),
+            url: z.string().nullable(),
+            workflow: z.string().optional(),
+            duration: z.string().optional(),
+        }))
+            .optional(),
+        checksStatus: z.enum(["none", "pending", "success", "failure"]).optional(),
+        reviewDecision: z.enum(["approved", "changes_requested", "pending"]).nullable().optional(),
+        repoOwner: z.string().optional(),
+        repoName: z.string().optional(),
+        github: z.unknown().optional(),
+    })
+        .nullable()
+        .optional(),
+    error: z
+        .object({
+        message: z.string(),
+    })
+        .nullable()
+        .optional(),
+    refreshedAt: z.string().nullable().optional(),
+})
+    .optional()
+    .nullable();
+export const WorkspaceDescriptorPayloadSchema = z
+    .object({
+    id: z.string(),
+    projectId: z.string(),
+    projectDisplayName: z.string(),
+    // COMPAT(projectCustomName): added in v0.1.76, drop the optional gate when floor >= v0.1.76.
+    // When the user has renamed a project, projectDisplayName carries the resolved
+    // value (customName) and projectCustomName mirrors the raw override so the
+    // settings UI can prefill its input and offer a "reset" action.
+    projectCustomName: z.string().nullable().optional(),
+    projectRootPath: z.string(),
+    workspaceDirectory: z.string().optional(),
+    projectKind: z.enum(["git", "non_git", "directory"]),
+    // COMPAT(workspaces): keep legacy directory workspace kind parseable.
+    workspaceKind: z.enum(["directory", "local_checkout", "checkout", "worktree"]),
+    name: z.string(),
+    // COMPAT(workspaceTitles): added in v0.1.97, drop the optional gate when floor >= v0.1.97.
+    // When the user has titled a workspace, `name` carries the resolved value
+    // (title) and `title` mirrors the raw override so the rename UI can prefill
+    // its input and offer a "reset to branch name" action. Null means the name
+    // is derived from the branch/directory.
+    title: z.string().nullable().optional(),
+    archivingAt: z.string().nullable().optional().default(null),
+    status: WorkspaceStateBucketSchema,
+    // Best-effort workspace status entry timestamp. Old daemons omit the
+    // field; old clients treat missing and null equivalently. The transform
+    // coerces a missing field to `null` so downstream code never has to
+    // handle `undefined`.
+    statusEnteredAt: z
+        .string()
+        .nullish()
+        .transform((value) => value ?? null),
+    activityAt: z.string().nullable(),
+    diffStat: z
+        .object({
+        additions: z.number(),
+        deletions: z.number(),
+    })
+        .nullable()
+        .optional(),
+    scripts: z.array(WorkspaceScriptPayloadSchema).default([]),
+    gitRuntime: WorkspaceGitRuntimePayloadSchema,
+    githubRuntime: WorkspaceGitHubRuntimePayloadSchema,
+    project: ProjectPlacementPayloadSchema.optional(),
+})
+    .transform((workspace) => ({
+    ...workspace,
+    workspaceDirectory: workspace.workspaceDirectory ?? workspace.projectRootPath,
+}));
+export const ArtifactUpdateMessageSchema = z.object({
+    type: z.literal("artifact_update"),
+    payload: z.object({
+        artifact: ArtifactMetadataSchema,
+    }),
+});
+export const AgentUpdateMessageSchema = z.object({
+    type: z.literal("agent_update"),
+    payload: z.discriminatedUnion("kind", [
+        z.object({
+            kind: z.literal("upsert"),
+            agent: AgentSnapshotPayloadSchema,
+            project: ProjectPlacementPayloadSchema.nullable().optional(),
+        }),
+        z.object({
+            kind: z.literal("remove"),
+            agentId: z.string(),
+        }),
+    ]),
+});
+export const AgentStreamMessageSchema = z.object({
+    type: z.literal("agent_stream"),
+    payload: z.object({
+        agentId: z.string(),
+        event: AgentStreamEventPayloadSchema,
+        timestamp: z.string(),
+        // Present for timeline events. Maps 1:1 to canonical in-memory timeline rows.
+        seq: z.number().int().nonnegative().optional(),
+        epoch: z.string().optional(),
+    }),
+});
+export const AgentStatusMessageSchema = z.object({
+    type: z.literal("agent_status"),
+    payload: z.object({
+        agentId: z.string(),
+        status: z.string(),
+        info: AgentSnapshotPayloadSchema,
+    }),
+});
+export const AgentListMessageSchema = z.object({
+    type: z.literal("agent_list"),
+    payload: z.object({
+        agents: z.array(AgentSnapshotPayloadSchema),
+    }),
+});
+const AgentDirectoryResponseEntrySchema = z.object({
+    agent: AgentSnapshotPayloadSchema,
+    project: ProjectPlacementPayloadSchema,
+});
+const AgentDirectoryPageInfoSchema = z.object({
+    nextCursor: z.string().nullable(),
+    prevCursor: z.string().nullable(),
+    hasMore: z.boolean(),
+});
+export const FetchAgentsResponseMessageSchema = z.object({
+    type: z.literal("fetch_agents_response"),
+    payload: z.object({
+        requestId: z.string(),
+        subscriptionId: z.string().nullable().optional(),
+        entries: z.array(AgentDirectoryResponseEntrySchema),
+        pageInfo: AgentDirectoryPageInfoSchema,
+    }),
+});
+export const FetchAgentHistoryResponseMessageSchema = z.object({
+    type: z.literal("fetch_agent_history_response"),
+    payload: z.object({
+        requestId: z.string(),
+        entries: z.array(AgentDirectoryResponseEntrySchema),
+        pageInfo: AgentDirectoryPageInfoSchema,
+    }),
+});
+export const FetchRecentProviderSessionsResponseMessageSchema = z.object({
+    type: z.literal("fetch_recent_provider_sessions_response"),
+    payload: z.object({
+        requestId: z.string(),
+        entries: z.array(RecentProviderSessionDescriptorPayloadSchema),
+        filteredAlreadyImportedCount: z.number().int().nonnegative().optional(),
+    }),
+});
+// COMPAT(workspaceProjects): added in v0.1.97, drop the optional gate when floor >= v0.1.97.
+// A project parent that has zero active workspaces. The sidebar renders the
+// project row with a new-workspace child so projects persist after their last
+// workspace is archived.
+export const WorkspaceProjectDescriptorPayloadSchema = z.object({
+    projectId: z.string(),
+    projectDisplayName: z.string(),
+    projectCustomName: z.string().nullable().optional(),
+    projectRootPath: z.string(),
+    projectKind: z.enum(["git", "non_git", "directory"]),
+});
+export const FetchWorkspacesResponseMessageSchema = z.object({
+    type: z.literal("fetch_workspaces_response"),
+    payload: z.object({
+        requestId: z.string(),
+        subscriptionId: z.string().nullable().optional(),
+        entries: z.array(WorkspaceDescriptorPayloadSchema),
+        // COMPAT(workspaceProjects): added in v0.1.97, drop the optional gate when floor >= v0.1.97.
+        // Project parents with no active workspaces. Old daemons omit it; old clients
+        // ignore it. Only populated on the first page (no cursor).
+        emptyProjects: z.array(WorkspaceProjectDescriptorPayloadSchema).optional().default([]),
+        pageInfo: z.object({
+            nextCursor: z.string().nullable(),
+            prevCursor: z.string().nullable(),
+            hasMore: z.boolean(),
+        }),
+    }),
+});
+export const WorkspaceUpdateMessageSchema = z.object({
+    type: z.literal("workspace_update"),
+    payload: z.discriminatedUnion("kind", [
+        z.object({
+            kind: z.literal("upsert"),
+            workspace: WorkspaceDescriptorPayloadSchema,
+        }),
+        z.object({
+            kind: z.literal("remove"),
+            id: z.string(),
+            // COMPAT(workspaceProjects): added in v0.1.97, drop the optional gate when floor >= v0.1.97.
+            // When archiving this workspace leaves its project with no active
+            // workspaces, the daemon includes the project parent so the sidebar keeps
+            // rendering it without waiting for a full re-hydration. Old daemons omit
+            // it; old clients ignore it and surface the project on their next
+            // workspace fetch instead.
+            emptyProject: WorkspaceProjectDescriptorPayloadSchema.optional(),
+            // Project removal is represented on the existing workspace update channel
+            // so old clients can still parse the message and ignore the extra field.
+            removedProjectId: z.string().optional(),
+        }),
+    ]),
+});
+export const ScriptStatusUpdateMessageSchema = z.object({
+    type: z.literal("script_status_update"),
+    payload: z.object({
+        workspaceId: z.string(),
+        scripts: z.array(WorkspaceScriptPayloadSchema),
+    }),
+});
+export const WorkspaceSetupProgressMessageSchema = z.object({
+    type: z.literal("workspace_setup_progress"),
+    payload: z.object({
+        workspaceId: z.string(),
+        status: z.enum(["running", "completed", "failed"]),
+        detail: WorktreeSetupDetailPayloadSchema,
+        error: z.string().nullable(),
+    }),
+});
+export const WorkspaceSetupSnapshotSchema = z.object({
+    status: z.enum(["running", "completed", "failed"]),
+    detail: WorktreeSetupDetailPayloadSchema,
+    error: z.string().nullable(),
+});
+export const WorkspaceSetupStatusResponseMessageSchema = z.object({
+    type: z.literal("workspace_setup_status_response"),
+    payload: z.object({
+        requestId: z.string(),
+        workspaceId: z.string(),
+        snapshot: WorkspaceSetupSnapshotSchema.nullable(),
+    }),
+});
+export const OpenProjectResponseMessageSchema = z.object({
+    type: z.literal("open_project_response"),
+    payload: z.object({
+        requestId: z.string(),
+        workspace: WorkspaceDescriptorPayloadSchema.nullable(),
+        error: z.string().nullable(),
+        // Unknown codes from newer daemons degrade to null; clients fall back to `error`.
+        errorCode: z.enum(["directory_not_found"]).nullish().catch(null),
+    }),
+});
+export const ProjectAddResponseSchema = z.object({
+    type: z.literal("project.add.response"),
+    payload: z.object({
+        requestId: z.string(),
+        project: WorkspaceProjectDescriptorPayloadSchema.nullable(),
+        error: z.string().nullable(),
+        errorCode: z.enum(["directory_not_found"]).nullish().catch(null),
+    }),
+});
+export const StartWorkspaceScriptResponseMessageSchema = z.object({
+    type: z.literal("start_workspace_script_response"),
+    payload: z.object({
+        requestId: z.string(),
+        workspaceId: z.string(),
+        scriptName: z.string(),
+        terminalId: z.string().nullable(),
+        error: z.string().nullable(),
+    }),
+});
+// COMPAT(desktopEditorBridge): added in v0.1.88, remove after 2026-12-03 once old clients no longer parse daemon editor RPC responses.
+export const LegacyListAvailableEditorsResponseMessageSchema = z.object({
+    type: z.literal("list_available_editors_response"),
+    payload: z.object({
+        requestId: z.string(),
+        editors: z.array(z.object({
+            id: z.string().trim().min(1),
+            label: z.string(),
+        })),
+        error: z.string().nullable(),
+    }),
+});
+export const LegacyOpenInEditorResponseMessageSchema = z.object({
+    type: z.literal("open_in_editor_response"),
+    payload: z.object({
+        requestId: z.string(),
+        error: z.string().nullable(),
+    }),
+});
+export const ArchiveWorkspaceResponseMessageSchema = z.object({
+    type: z.literal("archive_workspace_response"),
+    payload: z.object({
+        requestId: z.string(),
+        workspaceId: z.string(),
+        archivedAt: z.string().nullable(),
+        error: z.string().nullable(),
+    }),
+});
+export const FetchAgentResponseMessageSchema = z.object({
+    type: z.literal("fetch_agent_response"),
+    payload: z.object({
+        requestId: z.string(),
+        agent: AgentSnapshotPayloadSchema.nullable(),
+        project: ProjectPlacementPayloadSchema.nullable().optional(),
+        error: z.string().nullable(),
+    }),
+});
+const AgentTimelineSeqRangeSchema = z.object({
+    startSeq: z.number().int().nonnegative(),
+    endSeq: z.number().int().nonnegative(),
+});
+export const AgentTimelineEntryPayloadSchema = z.object({
+    provider: AgentProviderSchema,
+    item: AgentTimelineItemPayloadSchema,
+    timestamp: z.string(),
+    seqStart: z.number().int().nonnegative(),
+    seqEnd: z.number().int().nonnegative(),
+    sourceSeqRanges: z.array(AgentTimelineSeqRangeSchema),
+    collapsed: z.array(z.enum(["assistant_merge", "reasoning_merge", "tool_lifecycle"])),
+});
+export const FetchAgentTimelineResponseMessageSchema = z.object({
+    type: z.literal("fetch_agent_timeline_response"),
+    payload: z.object({
+        requestId: z.string(),
+        agentId: z.string(),
+        agent: AgentSnapshotPayloadSchema.nullable(),
+        direction: z.enum(["tail", "before", "after"]),
+        projection: z.enum(["projected", "canonical"]),
+        epoch: z.string(),
+        reset: z.boolean(),
+        staleCursor: z.boolean(),
+        gap: z.boolean(),
+        window: z.object({
+            minSeq: z.number().int().nonnegative(),
+            maxSeq: z.number().int().nonnegative(),
+            nextSeq: z.number().int().nonnegative(),
+        }),
+        startCursor: AgentTimelineCursorSchema.nullable(),
+        endCursor: AgentTimelineCursorSchema.nullable(),
+        hasOlder: z.boolean(),
+        hasNewer: z.boolean(),
+        entries: z.array(AgentTimelineEntryPayloadSchema),
+        error: z.string().nullable(),
+    }),
+});
+export const AgentForkContextResponseMessageSchema = z.object({
+    type: z.literal("agent.fork_context.response"),
+    payload: z.object({
+        requestId: z.string(),
+        agentId: z.string(),
+        attachment: TextAttachmentSchema.nullable(),
+        itemCount: z.number().int().nonnegative(),
+        boundaryMessageId: z.string().nullable(),
+        error: z.string().nullable(),
+    }),
+});
+export const CancelAgentResponseMessageSchema = z.object({
+    type: z.literal("cancel_agent_response"),
+    payload: z.object({
+        requestId: z.string(),
+        agentId: z.string(),
+        agent: AgentSnapshotPayloadSchema.nullable(),
+    }),
+});
+export const ClearAgentAttentionResponseMessageSchema = z.object({
+    type: z.literal("clear_agent_attention_response"),
+    payload: z.object({
+        requestId: z.string(),
+        agentId: z.string().or(z.array(z.string())),
+        agents: z.array(AgentSnapshotPayloadSchema),
+    }),
+});
+export const WorkspaceCreateResponseSchema = z.object({
+    type: z.literal("workspace.create.response"),
+    payload: z.object({
+        workspace: WorkspaceDescriptorPayloadSchema.nullable(),
+        setupTerminalId: z.string().nullable(),
+        error: z.string().nullable(),
+        errorCode: z.string().optional(),
+        requestId: z.string(),
+    }),
+});
+export const WorkspaceClearAttentionResponseSchema = z.object({
+    type: z.literal("workspace.clear_attention.response"),
+    payload: z.object({
+        requestId: z.string(),
+        workspaceId: z.union([z.string(), z.array(z.string())]),
+        clearedAgentIds: z.array(z.string()),
+        results: z.array(z.object({
+            workspaceId: z.string(),
+            clearedAgentIds: z.array(z.string()),
+            success: z.boolean(),
+            error: z.string().nullable(),
+        })),
+        success: z.boolean(),
+        error: z.string().nullable(),
+    }),
+});
+export const SendAgentMessageResponseMessageSchema = z.object({
+    type: z.literal("send_agent_message_response"),
+    payload: z.object({
+        requestId: z.string(),
+        agentId: z.string(),
+        accepted: z.boolean(),
+        error: z.string().nullable(),
+    }),
+});
+export const WaitForFinishResponseMessageSchema = z.object({
+    type: z.literal("wait_for_finish_response"),
+    payload: z.object({
+        requestId: z.string(),
+        status: z.enum(["idle", "error", "permission", "timeout"]),
+        final: AgentSnapshotPayloadSchema.nullable(),
+        error: z.string().nullable(),
+        lastMessage: z.string().nullable(),
+    }),
+});
+export const GetDaemonConfigResponseMessageSchema = z.object({
+    type: z.literal("get_daemon_config_response"),
+    payload: z
+        .object({
+        requestId: z.string(),
+        config: MutableDaemonConfigSchema,
+    })
+        .passthrough(),
+});
+const SpeechEngineOptionSchema = z.object({
+    id: z.string(),
+    available: z.boolean(),
+    reason: z.string().optional(),
+});
+const LocalSpeechSttModelOptionSchema = z.object({
+    id: z.string(),
+    // Short display name (e.g. "Parakeet v2 (English)"); older daemons omit it
+    // and clients fall back to the id.
+    label: z.string().optional(),
+    description: z.string(),
+});
+const LocalSpeechTtsModelOptionSchema = z.object({
+    id: z.string(),
+    label: z.string().optional(),
+    description: z.string(),
+    voices: z.array(z.string()),
+    defaultVoice: z.string(),
+});
+export const SpeechSettingsGetOptionsResponseSchema = z.object({
+    type: z.literal("speech.settings.get_options.response"),
+    payload: z
+        .object({
+        requestId: z.string(),
+        options: z.object({
+            sttEngines: z.array(SpeechEngineOptionSchema),
+            ttsEngines: z.array(SpeechEngineOptionSchema),
+            local: z.object({
+                sttModels: z.array(LocalSpeechSttModelOptionSchema),
+                ttsModels: z.array(LocalSpeechTtsModelOptionSchema),
+            }),
+            openai: z.object({
+                configured: z.boolean(),
+                sttModels: z.array(z.string()),
+                ttsModels: z.array(z.string()),
+                ttsVoices: z.array(z.string()),
+            }),
+        }),
+    })
+        .passthrough(),
+});
+export const SpeechTtsPreviewResponseSchema = z.object({
+    type: z.literal("speech.tts.preview.response"),
+    payload: z
+        .object({
+        requestId: z.string(),
+        // base64-encoded audio bytes; absent when synthesis failed (see error).
+        audio: z.string().optional(),
+        // Media type carrying the sample rate, e.g. "audio/pcm;rate=24000",
+        // so the client audio engine plays it back at the correct pitch.
+        format: z.string().optional(),
+        // Human-readable failure reason when audio could not be produced.
+        error: z.string().optional(),
+    })
+        .passthrough(),
+});
+export const AgentPersonalitiesGetStatsResponseSchema = z.object({
+    type: z.literal("agentPersonalities.get_stats.response"),
+    payload: z
+        .object({
+        requestId: z.string(),
+        // Per-personality spawn counts, keyed by personality id.
+        stats: z.record(z.string(), z.number()),
+    })
+        .passthrough(),
+});
+export const DaemonGetStatusResponseSchema = z.object({
+    type: z.literal("daemon.get_status.response"),
+    payload: z
+        .object({
+        requestId: z.string(),
+        serverId: z.string(),
+        version: z.string().nullable().optional(),
+        pid: z.number(),
+        nodePath: z.string(),
+        startedAt: z.string().nullable().optional(),
+        listen: z.string().nullable(),
+        relay: z
+            .object({
+            enabled: z.boolean(),
+            endpoint: z.string(),
+            publicEndpoint: z.string(),
+            useTls: z.boolean(),
+            publicUseTls: z.boolean(),
+        })
+            .nullable()
+            .optional(),
+        providers: z.array(z.object({
+            provider: z.string(),
+            available: z.boolean(),
+            error: z.string().nullable().optional(),
+        })),
+    })
+        .passthrough(),
+});
+export const DaemonGetPairingOfferResponseSchema = z.object({
+    type: z.literal("daemon.get_pairing_offer.response"),
+    payload: z
+        .object({
+        requestId: z.string(),
+        url: z.string(),
+        qr: z.string().nullable().optional(),
+        relayEnabled: z.boolean(),
+    })
+        .passthrough(),
+});
+export const DiagnosticsResponseSchema = z.object({
+    type: z.literal("diagnostics.response"),
+    payload: z
+        .object({
+        requestId: z.string(),
+        diagnostic: z.string(),
+    })
+        .passthrough(),
+});
+export const SetDaemonConfigResponseMessageSchema = z.object({
+    type: z.literal("set_daemon_config_response"),
+    payload: z
+        .object({
+        requestId: z.string(),
+        config: MutableDaemonConfigSchema,
+    })
+        .passthrough(),
+});
+export const ReadProjectConfigResponseMessageSchema = z.object({
+    type: z.literal("read_project_config_response"),
+    // zod-aot 0.2.0 miscompiles boolean discriminators as string options
+    // (`"true"`/`"false"`), so keep this sequential until upstream fixes it.
+    payload: z.union([
+        z.object({
+            requestId: z.string(),
+            repoRoot: z.string(),
+            ok: z.literal(true),
+            config: OttoConfigRawSchema.nullable(),
+            revision: OttoConfigRevisionSchema.nullable(),
+        }),
+        z.object({
+            requestId: z.string(),
+            repoRoot: z.string(),
+            ok: z.literal(false),
+            error: ProjectConfigRpcErrorSchema,
+        }),
+    ]),
+});
+export const WriteProjectConfigResponseMessageSchema = z.object({
+    type: z.literal("write_project_config_response"),
+    // zod-aot 0.2.0 miscompiles boolean discriminators as string options
+    // (`"true"`/`"false"`), so keep this sequential until upstream fixes it.
+    payload: z.union([
+        z.object({
+            requestId: z.string(),
+            repoRoot: z.string(),
+            ok: z.literal(true),
+            config: OttoConfigRawSchema,
+            revision: OttoConfigRevisionSchema,
+        }),
+        z.object({
+            requestId: z.string(),
+            repoRoot: z.string(),
+            ok: z.literal(false),
+            error: ProjectConfigRpcErrorSchema,
+        }),
+    ]),
+});
+export const AgentPermissionRequestMessageSchema = z.object({
+    type: z.literal("agent_permission_request"),
+    payload: z.object({
+        agentId: z.string(),
+        request: AgentPermissionRequestPayloadSchema,
+    }),
+});
+export const AgentPermissionResolvedMessageSchema = z.object({
+    type: z.literal("agent_permission_resolved"),
+    payload: z.object({
+        agentId: z.string(),
+        requestId: z.string(),
+        resolution: AgentPermissionResponseSchema,
+    }),
+});
+export const AgentDeletedMessageSchema = z.object({
+    type: z.literal("agent_deleted"),
+    payload: z.object({
+        agentId: z.string(),
+        requestId: z.string(),
+    }),
+});
+export const AgentArchivedMessageSchema = z.object({
+    type: z.literal("agent_archived"),
+    payload: z.object({
+        agentId: z.string(),
+        archivedAt: z.string(),
+        requestId: z.string(),
+    }),
+});
+const CloseItemsAgentResultSchema = z.object({
+    agentId: z.string(),
+    archivedAt: z.string(),
+});
+const CloseItemsTerminalResultSchema = z.object({
+    terminalId: z.string(),
+    success: z.boolean(),
+});
+export const CloseItemsResponseSchema = z.object({
+    type: z.literal("close_items_response"),
+    payload: z.object({
+        agents: z.array(CloseItemsAgentResultSchema),
+        terminals: z.array(CloseItemsTerminalResultSchema),
+        requestId: z.string(),
+    }),
+});
+const AheadBehindSchema = z.object({
+    ahead: z.number(),
+    behind: z.number(),
+});
+const CheckoutStatusCommonSchema = z.object({
+    cwd: z.string(),
+    error: CheckoutErrorSchema.nullable(),
+    requestId: z.string(),
+});
+const CheckoutStatusNotGitSchema = CheckoutStatusCommonSchema.extend({
+    isGit: z.literal(false),
+    isOttoOwnedWorktree: z.literal(false),
+    repoRoot: z.null(),
+    currentBranch: z.null(),
+    isDirty: z.null(),
+    baseRef: z.null(),
+    aheadBehind: z.null(),
+    aheadOfOrigin: z.null(),
+    behindOfOrigin: z.null(),
+    hasRemote: z.boolean(),
+    remoteUrl: z.null(),
+});
+const CheckoutStatusGitNonOttoSchema = CheckoutStatusCommonSchema.extend({
+    isGit: z.literal(true),
+    isOttoOwnedWorktree: z.literal(false),
+    repoRoot: z.string(),
+    mainRepoRoot: z.string().nullable().optional().default(null),
+    currentBranch: z.string().nullable(),
+    isDirty: z.boolean(),
+    baseRef: z.string().nullable(),
+    aheadBehind: AheadBehindSchema.nullable(),
+    aheadOfOrigin: z.number().nullable(),
+    behindOfOrigin: z.number().nullable(),
+    hasRemote: z.boolean(),
+    remoteUrl: z.string().nullable(),
+});
+const CheckoutStatusGitOttoSchema = CheckoutStatusCommonSchema.extend({
+    isGit: z.literal(true),
+    isOttoOwnedWorktree: z.literal(true),
+    repoRoot: z.string(),
+    mainRepoRoot: z.string(),
+    currentBranch: z.string().nullable(),
+    isDirty: z.boolean(),
+    baseRef: z.string(),
+    aheadBehind: AheadBehindSchema.nullable(),
+    aheadOfOrigin: z.number().nullable(),
+    behindOfOrigin: z.number().nullable(),
+    hasRemote: z.boolean(),
+    remoteUrl: z.string().nullable(),
+});
+export const CheckoutStatusResponseSchema = z.object({
+    type: z.literal("checkout_status_response"),
+    payload: z.union([
+        CheckoutStatusNotGitSchema,
+        CheckoutStatusGitNonOttoSchema,
+        CheckoutStatusGitOttoSchema,
+    ]),
+});
+const CheckoutPrGithubAutoMergeRequestSchema = z
+    .object({
+    enabledAt: z.string().nullable().optional().default(null),
+    mergeMethod: z.string().nullable().optional().default(null),
+    enabledBy: z.string().nullable().optional().default(null),
+})
+    .nullable()
+    .optional()
+    .default(null);
+const CheckoutPrGithubRepositoryPolicySchema = z
+    .object({
+    autoMergeAllowed: z.boolean().optional().default(false),
+    mergeCommitAllowed: z.boolean().optional().default(false),
+    squashMergeAllowed: z.boolean().optional().default(false),
+    rebaseMergeAllowed: z.boolean().optional().default(false),
+    viewerDefaultMergeMethod: z.string().nullable().optional().default(null),
+})
+    .optional()
+    .default({
+    autoMergeAllowed: false,
+    mergeCommitAllowed: false,
+    squashMergeAllowed: false,
+    rebaseMergeAllowed: false,
+    viewerDefaultMergeMethod: null,
+});
+const CheckoutPrGithubStatusSchema = z
+    .object({
+    mergeStateStatus: z.string().nullable().optional().default(null),
+    autoMergeRequest: CheckoutPrGithubAutoMergeRequestSchema,
+    viewerCanEnableAutoMerge: z.boolean().optional().default(false),
+    viewerCanDisableAutoMerge: z.boolean().optional().default(false),
+    viewerCanMergeAsAdmin: z.boolean().optional().default(false),
+    viewerCanUpdateBranch: z.boolean().optional().default(false),
+    repository: CheckoutPrGithubRepositoryPolicySchema,
+    isMergeQueueEnabled: z.boolean().optional().default(false),
+    isInMergeQueue: z.boolean().optional().default(false),
+})
+    .optional();
+export const CheckoutPrStatusSchema = z.object({
+    number: z.number().optional(),
+    url: z.string(),
+    title: z.string(),
+    state: z.string(),
+    baseRefName: z.string(),
+    headRefName: z.string(),
+    isMerged: z.boolean(),
+    isDraft: z.boolean().optional().default(false),
+    mergeable: z
+        .enum(["MERGEABLE", "CONFLICTING", "UNKNOWN"])
+        .catch("UNKNOWN")
+        .optional()
+        .default("UNKNOWN"),
+    checks: z
+        .array(z.object({
+        name: z.string(),
+        status: z.string(),
+        url: z.string().nullable(),
+        workflow: z.string().optional(),
+        duration: z.string().optional(),
+        checkRunId: z.number().optional(),
+        workflowRunId: z.number().optional(),
+    }))
+        .optional()
+        .default([]),
+    checksStatus: z.string().optional(),
+    reviewDecision: z.string().nullable().optional(),
+    repoOwner: z.string().optional(),
+    repoName: z.string().optional(),
+    github: CheckoutPrGithubStatusSchema,
+    // Provider-neutral per-PR hosting facts. Absent from old daemons; for
+    // GitHub projects both this and the legacy `github` field are populated.
+    hosting: z
+        .object({
+        provider: GitHostingProviderIdWireSchema,
+        bitbucket: z
+            .object({
+            mergeStrategiesAllowed: z.array(z.string()).optional().default([]),
+            defaultMergeStrategy: z.string().nullable().optional().default(null),
+            approvalCount: z.number().optional().default(0),
+            changesRequestedCount: z.number().optional().default(0),
+        })
+            .optional(),
+    })
+        .optional(),
+});
+const CheckoutPrStatusPayloadSchema = z.object({
+    cwd: z.string(),
+    status: CheckoutPrStatusSchema.nullable(),
+    // Legacy GitHub-only flag. For non-GitHub providers new daemons send false
+    // here (old clients then correctly show no GitHub features) and describe
+    // the real provider in `hosting` below.
+    githubFeaturesEnabled: z.boolean(),
+    // Provider-neutral enablement. Present even when status is null so clients
+    // can drive search/create-PR affordances for the workspace's provider.
+    hosting: z
+        .object({
+        provider: GitHostingProviderIdWireSchema,
+        featuresEnabled: z.boolean(),
+        capabilities: GitHostingCapabilitiesSchema.optional(),
+    })
+        .optional(),
+    error: CheckoutErrorSchema.nullable(),
+    requestId: z.string(),
+});
+const CheckoutStatusUpdateMetadataSchema = z.object({
+    prStatus: CheckoutPrStatusPayloadSchema.optional(),
+});
+export const CheckoutStatusUpdateSchema = z.object({
+    type: z.literal("checkout_status_update"),
+    payload: z
+        .union([
+        CheckoutStatusNotGitSchema,
+        CheckoutStatusGitNonOttoSchema,
+        CheckoutStatusGitOttoSchema,
+    ])
+        .and(CheckoutStatusUpdateMetadataSchema),
+});
+const CheckoutDiffSubscriptionPayloadSchema = z.object({
+    subscriptionId: z.string(),
+    cwd: z.string(),
+    files: z.array(ParsedDiffFileSchema),
+    error: CheckoutErrorSchema.nullable(),
+});
+export const SubscribeCheckoutDiffResponseSchema = z.object({
+    type: z.literal("subscribe_checkout_diff_response"),
+    payload: CheckoutDiffSubscriptionPayloadSchema.extend({
+        requestId: z.string(),
+    }),
+});
+export const CheckoutDiffUpdateSchema = z.object({
+    type: z.literal("checkout_diff_update"),
+    payload: CheckoutDiffSubscriptionPayloadSchema,
+});
+export const CheckoutCommitResponseSchema = z.object({
+    type: z.literal("checkout_commit_response"),
+    payload: z.object({
+        cwd: z.string(),
+        success: z.boolean(),
+        error: CheckoutErrorSchema.nullable(),
+        requestId: z.string(),
+    }),
+});
+export const CheckoutMergeResponseSchema = z.object({
+    type: z.literal("checkout_merge_response"),
+    payload: z.object({
+        cwd: z.string(),
+        success: z.boolean(),
+        error: CheckoutErrorSchema.nullable(),
+        requestId: z.string(),
+    }),
+});
+export const CheckoutMergeFromBaseResponseSchema = z.object({
+    type: z.literal("checkout_merge_from_base_response"),
+    payload: z.object({
+        cwd: z.string(),
+        success: z.boolean(),
+        error: CheckoutErrorSchema.nullable(),
+        requestId: z.string(),
+    }),
+});
+export const CheckoutPullResponseSchema = z.object({
+    type: z.literal("checkout_pull_response"),
+    payload: z.object({
+        cwd: z.string(),
+        success: z.boolean(),
+        error: CheckoutErrorSchema.nullable(),
+        requestId: z.string(),
+    }),
+});
+export const CheckoutPushResponseSchema = z.object({
+    type: z.literal("checkout_push_response"),
+    payload: z.object({
+        cwd: z.string(),
+        success: z.boolean(),
+        error: CheckoutErrorSchema.nullable(),
+        requestId: z.string(),
+    }),
+});
+export const CheckoutRefreshResponseSchema = z.object({
+    type: z.literal("checkout.refresh.response"),
+    payload: z.object({
+        cwd: z.string(),
+        success: z.boolean(),
+        error: CheckoutErrorSchema.nullable(),
+        requestId: z.string(),
+    }),
+});
+export const CheckoutPrCreateResponseSchema = z.object({
+    type: z.literal("checkout_pr_create_response"),
+    payload: z.object({
+        cwd: z.string(),
+        url: z.string().nullable(),
+        number: z.number().nullable(),
+        error: CheckoutErrorSchema.nullable(),
+        requestId: z.string(),
+    }),
+});
+export const CheckoutPrMergeResponseSchema = z.object({
+    type: z.literal("checkout_pr_merge_response"),
+    payload: z.object({
+        cwd: z.string(),
+        success: z.boolean(),
+        error: CheckoutErrorSchema.nullable(),
+        requestId: z.string(),
+    }),
+});
+export const CheckoutGithubSetAutoMergeResponseSchema = z.object({
+    type: z.literal("checkout.github.set_auto_merge.response"),
+    payload: z.object({
+        cwd: z.string(),
+        enabled: z.boolean(),
+        success: z.boolean(),
+        error: CheckoutErrorSchema.nullable(),
+        requestId: z.string(),
+    }),
+});
+export const PreviewConfiguredServerSchema = z.object({
+    name: z.string(),
+    port: z.number().int().positive(),
+});
+export const PreviewServerStatusSchema = z.enum(["starting", "running", "exited"]);
+export const PreviewRunningServerSchema = z.object({
+    serverId: z.string(),
+    name: z.string(),
+    url: z.string(),
+    port: z.number().int().positive(),
+    status: PreviewServerStatusSchema,
+});
+export const PreviewListConfigResponseSchema = z.object({
+    type: z.literal("preview.list_config.response"),
+    payload: z.object({
+        cwd: z.string(),
+        configured: z.boolean(),
+        servers: z.array(PreviewConfiguredServerSchema),
+        runningServers: z.array(PreviewRunningServerSchema).optional(),
+        error: z.string().nullable(),
+        requestId: z.string(),
+    }),
+});
+// Preview servers the daemon did not spawn (port-probed from launch.json, e.g.
+// a dev server the user started by hand) are addressed by an "ext:<port>" id.
+// Stopping one tree-kills whatever process owns the port, so bulk cleanup paths
+// must skip external servers and only explicit user action may stop them.
+export const EXTERNAL_PREVIEW_SERVER_ID_PREFIX = "ext:";
+export function isExternalPreviewServerId(serverId) {
+    return serverId.startsWith(EXTERNAL_PREVIEW_SERVER_ID_PREFIX);
+}
+export const PreviewServerSummaryPayloadSchema = z.object({
+    serverId: z.string(),
+    name: z.string(),
+    url: z.string(),
+    port: z.number().int().positive(),
+    status: z.enum(["starting", "running", "exited"]),
+    boundBrowserId: z.string().nullable(),
+});
+export const PreviewStartResponseSchema = z.object({
+    type: z.literal("preview.start.response"),
+    payload: z.object({
+        cwd: z.string(),
+        success: z.boolean(),
+        server: PreviewServerSummaryPayloadSchema.nullable(),
+        reused: z.boolean(),
+        error: z.string().nullable(),
+        requestId: z.string(),
+    }),
+});
+export const PreviewBindTabResponseSchema = z.object({
+    type: z.literal("preview.bind_tab.response"),
+    payload: z.object({
+        success: z.boolean(),
+        error: z.string().nullable(),
+        requestId: z.string(),
+    }),
+});
+export const PreviewStopResponseSchema = z.object({
+    type: z.literal("preview.stop.response"),
+    payload: z.object({
+        success: z.boolean(),
+        error: z.string().nullable(),
+        requestId: z.string(),
+    }),
+});
+const CheckoutGithubCheckAnnotationSchema = z.object({
+    path: z.string().optional(),
+    startLine: z.number().optional(),
+    endLine: z.number().optional(),
+    annotationLevel: z.string().optional(),
+    message: z.string().optional(),
+    title: z.string().optional(),
+    rawDetails: z.string().optional(),
+});
+const CheckoutGithubCheckJobSchema = z.object({
+    jobId: z.number(),
+    name: z.string(),
+    status: z.string().nullable().optional(),
+    conclusion: z.string().nullable().optional(),
+    url: z.string().nullable().optional(),
+    logTail: z.string().optional(),
+    logTruncated: z.boolean().optional(),
+});
+export const CheckoutGithubCheckDetailsSchema = z.object({
+    checkRunId: z.number(),
+    workflowRunId: z.number().nullable().optional(),
+    name: z.string(),
+    status: z.string().nullable().optional(),
+    conclusion: z.string().nullable().optional(),
+    url: z.string().nullable().optional(),
+    detailsUrl: z.string().nullable().optional(),
+    output: z
+        .object({
+        title: z.string().nullable().optional(),
+        summary: z.string().nullable().optional(),
+        text: z.string().nullable().optional(),
+    })
+        .nullable()
+        .optional(),
+    annotations: z.array(CheckoutGithubCheckAnnotationSchema).optional().default([]),
+    failedJobs: z.array(CheckoutGithubCheckJobSchema).optional().default([]),
+    truncated: z.boolean().optional().default(false),
+});
+export const CheckoutGithubGetCheckDetailsResponseSchema = z.object({
+    type: z.literal("checkout.github.get_check_details.response"),
+    payload: z.object({
+        cwd: z.string(),
+        success: z.boolean(),
+        details: CheckoutGithubCheckDetailsSchema.nullable().optional().default(null),
+        error: CheckoutErrorSchema.nullable(),
+        requestId: z.string(),
+    }),
+});
+export const CheckoutPrStatusResponseSchema = z.object({
+    type: z.literal("checkout_pr_status_response"),
+    payload: CheckoutPrStatusPayloadSchema,
+});
+const PullRequestTimelineKnownErrorSchema = z.discriminatedUnion("kind", [
+    z.object({
+        kind: z.literal("not_found"),
+        message: z.string().optional().default(""),
+    }),
+    z.object({
+        kind: z.literal("forbidden"),
+        message: z.string().optional().default(""),
+    }),
+    z.object({
+        kind: z.literal("unknown"),
+        message: z.string().optional().default(""),
+    }),
+]);
+const PullRequestTimelineErrorSchema = z.preprocess((value) => {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        return { kind: "unknown", message: "" };
+    }
+    const error = value;
+    if (error.kind === "not_found" || error.kind === "forbidden" || error.kind === "unknown") {
+        return error;
+    }
+    return { ...error, kind: "unknown" };
+}, PullRequestTimelineKnownErrorSchema);
+const PullRequestTimelineReviewItemSchema = z.object({
+    id: z.string().optional().default(""),
+    kind: z.literal("review"),
+    author: z.string().optional().default("unknown"),
+    authorUrl: z.string().nullable().optional(),
+    avatarUrl: z.string().nullable().optional(),
+    body: z.string().optional().default(""),
+    createdAt: z.number().optional().default(0),
+    url: z.string().optional().default(""),
+    reviewState: z
+        .enum(["approved", "changes_requested", "commented"])
+        .optional()
+        .default("commented"),
+});
+const PullRequestTimelineCommentItemSchema = z.object({
+    id: z.string().optional().default(""),
+    kind: z.literal("comment"),
+    author: z.string().optional().default("unknown"),
+    authorUrl: z.string().nullable().optional(),
+    avatarUrl: z.string().nullable().optional(),
+    body: z.string().optional().default(""),
+    createdAt: z.number().optional().default(0),
+    url: z.string().optional().default(""),
+    // GitHub review id this inline comment belongs to; lets clients nest review
+    // threads under their parent review. Absent on issue comments and on
+    // timelines from daemons that predate the field.
+    reviewId: z.string().optional(),
+    location: z
+        .object({
+        path: z.string(),
+        line: z.number().optional(),
+        startLine: z.number().optional(),
+        threadId: z.string().optional(),
+        isResolved: z.boolean().optional(),
+        isOutdated: z.boolean().optional(),
+    })
+        .optional(),
+});
+export const PullRequestTimelineItemSchema = z.preprocess((value) => {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        return value;
+    }
+    const item = value;
+    if (item.kind === "review" || item.kind === "comment") {
+        return item;
+    }
+    return { ...item, kind: "comment" };
+}, z.discriminatedUnion("kind", [
+    PullRequestTimelineReviewItemSchema,
+    PullRequestTimelineCommentItemSchema,
+]));
+export const PullRequestTimelineResponseSchema = z.object({
+    type: z.literal("pull_request_timeline_response"),
+    payload: z
+        .object({
+        cwd: z.string().optional().default(""),
+        prNumber: z.number().nullable().optional().default(null),
+        items: z.array(PullRequestTimelineItemSchema).optional().default([]),
+        truncated: z.boolean().optional().default(false),
+        error: PullRequestTimelineErrorSchema.nullable().optional().default(null),
+        requestId: z.string().optional().default(""),
+        githubFeaturesEnabled: z.boolean().optional().default(true),
+    })
+        .optional()
+        .prefault({}),
+});
+export const CheckoutSwitchBranchResponseSchema = z.object({
+    type: z.literal("checkout_switch_branch_response"),
+    payload: z.object({
+        cwd: z.string(),
+        success: z.boolean(),
+        branch: z.string(),
+        source: z.enum(["local", "remote"]).optional(),
+        error: CheckoutErrorSchema.nullable(),
+        requestId: z.string(),
+    }),
+});
+export const CheckoutRenameBranchResponseSchema = z.object({
+    type: z.literal("checkout.rename_branch.response"),
+    payload: z.object({
+        requestId: z.string(),
+        success: z.boolean(),
+        cwd: z.string(),
+        currentBranch: z.string().nullable(),
+        error: CheckoutErrorSchema.nullable(),
+    }),
+});
+const StashEntrySchema = z.object({
+    index: z.number().int().min(0),
+    message: z.string(),
+    branch: z.string().nullable(),
+    isOtto: z.boolean(),
+});
+export const StashSaveResponseSchema = z.object({
+    type: z.literal("stash_save_response"),
+    payload: z.object({
+        cwd: z.string(),
+        success: z.boolean(),
+        error: CheckoutErrorSchema.nullable(),
+        requestId: z.string(),
+    }),
+});
+export const StashPopResponseSchema = z.object({
+    type: z.literal("stash_pop_response"),
+    payload: z.object({
+        cwd: z.string(),
+        success: z.boolean(),
+        error: CheckoutErrorSchema.nullable(),
+        requestId: z.string(),
+    }),
+});
+export const StashListResponseSchema = z.object({
+    type: z.literal("stash_list_response"),
+    payload: z.object({
+        cwd: z.string(),
+        entries: z.array(StashEntrySchema),
+        error: CheckoutErrorSchema.nullable(),
+        requestId: z.string(),
+    }),
+});
+export const ValidateBranchResponseSchema = z.object({
+    type: z.literal("validate_branch_response"),
+    payload: z.object({
+        exists: z.boolean(),
+        resolvedRef: z.string().nullable(),
+        isRemote: z.boolean(),
+        error: z.string().nullable(),
+        requestId: z.string(),
+    }),
+});
+export const BranchSuggestionsResponseSchema = z.object({
+    type: z.literal("branch_suggestions_response"),
+    payload: z.object({
+        branches: z.array(z.string()),
+        branchDetails: z
+            .array(z.object({
+            name: z.string(),
+            committerDate: z.number(),
+            hasLocal: z.boolean().optional(),
+            hasRemote: z.boolean().optional(),
+        }))
+            .optional(),
+        error: z.string().nullable(),
+        requestId: z.string(),
+    }),
+});
+export const GitHubSearchResponseSchema = z.object({
+    type: z.literal("github_search_response"),
+    payload: z.object({
+        items: z.array(GitHubSearchItemSchema),
+        githubFeaturesEnabled: z.boolean(),
+        error: z.string().nullable(),
+        requestId: z.string(),
+    }),
+});
+export const HostingSearchResponseSchema = z.object({
+    type: z.literal("hosting.search.response"),
+    payload: z.object({
+        items: z.array(GitHubSearchItemSchema),
+        provider: GitHostingProviderIdWireSchema,
+        featuresEnabled: z.boolean(),
+        error: z.string().nullable(),
+        requestId: z.string(),
+    }),
+});
+export const HostingAuthStatusResponseSchema = z.object({
+    type: z.literal("hosting.auth_status.response"),
+    payload: z.object({
+        provider: GitHostingProviderIdWireSchema,
+        authenticated: z.boolean(),
+        error: z.string().nullable(),
+        requestId: z.string(),
+    }),
+});
+export const DirectorySuggestionsResponseSchema = z.object({
+    type: z.literal("directory_suggestions_response"),
+    payload: z.object({
+        directories: z.array(z.string()),
+        entries: z
+            .array(z.object({
+            path: z.string(),
+            kind: z.enum(["file", "directory"]),
+        }))
+            .optional()
+            .default([]),
+        error: z.string().nullable(),
+        requestId: z.string(),
+    }),
+});
+const OttoWorktreeSchema = z.object({
+    worktreePath: z.string(),
+    createdAt: z.string(),
+    branchName: z.string().nullable().optional(),
+    head: z.string().nullable().optional(),
+});
+export const OttoWorktreeListResponseSchema = z.object({
+    type: z.literal("otto_worktree_list_response"),
+    payload: z.object({
+        worktrees: z.array(OttoWorktreeSchema),
+        error: CheckoutErrorSchema.nullable(),
+        requestId: z.string(),
+    }),
+});
+export const OttoWorktreeArchiveResponseSchema = z.object({
+    type: z.literal("otto_worktree_archive_response"),
+    payload: z.object({
+        success: z.boolean(),
+        removedAgents: z.array(z.string()).optional(),
+        error: CheckoutErrorSchema.nullable(),
+        requestId: z.string(),
+    }),
+});
+export const CreateOttoWorktreeResponseSchema = z.object({
+    type: z.literal("create_otto_worktree_response"),
+    payload: z.object({
+        workspace: WorkspaceDescriptorPayloadSchema.nullable(),
+        error: z.string().nullable(),
+        errorCode: z.string().optional(),
+        setupTerminalId: z.string().nullable(),
+        requestId: z.string(),
+    }),
+});
+export const FileExplorerResponseSchema = z.object({
+    type: z.literal("file_explorer_response"),
+    payload: z.object({
+        cwd: z.string(),
+        path: z.string(),
+        mode: z.enum(["list", "file"]),
+        directory: FileExplorerDirectorySchema.nullable(),
+        file: FileExplorerFileSchema.nullable(),
+        error: z.string().nullable(),
+        requestId: z.string(),
+    }),
+});
+const ProjectIconSchema = z.object({
+    data: z.string(),
+    mimeType: z.string(),
+});
+export const ProjectIconResponseSchema = z.object({
+    type: z.literal("project_icon_response"),
+    payload: z.object({
+        cwd: z.string(),
+        icon: ProjectIconSchema.nullable(),
+        error: z.string().nullable(),
+        requestId: z.string(),
+    }),
+});
+export const FileDownloadTokenResponseSchema = z.object({
+    type: z.literal("file_download_token_response"),
+    payload: z.object({
+        cwd: z.string(),
+        path: z.string(),
+        token: z.string().nullable(),
+        fileName: z.string().nullable(),
+        mimeType: z.string().nullable(),
+        size: z.number().nullable(),
+        error: z.string().nullable(),
+        requestId: z.string(),
+    }),
+});
+export const FileUploadResponseSchema = z.object({
+    type: z.literal("file.upload.response"),
+    payload: z.object({
+        requestId: z.string(),
+        file: UploadedFileAttachmentSchema.nullable(),
+        error: z.string().nullable(),
+    }),
+});
+export const FileWriteResultSchema = z.discriminatedUnion("status", [
+    z.object({
+        status: z.literal("ok"),
+        modifiedAt: z.string(),
+        hash: z.string(),
+        size: z.number(),
+        eol: FileEolSchema,
+    }),
+    // The file on disk is not what the client last saw; nothing was written.
+    // `content` carries the current disk text so the client can offer reload or
+    // an informed overwrite (a second conditional write against this identity)
+    // without another round-trip.
+    z.object({
+        status: z.literal("conflict"),
+        modifiedAt: z.string(),
+        hash: z.string(),
+        content: z.string().optional(),
+        eol: FileEolSchema.optional(),
+    }),
+    z.object({
+        status: z.literal("error"),
+        message: z.string(),
+    }),
+]);
+export const FileWriteResponseSchema = z.object({
+    type: z.literal("file.write.response"),
+    payload: z.object({
+        cwd: z.string(),
+        path: z.string(),
+        result: FileWriteResultSchema,
+        requestId: z.string(),
+    }),
+});
+export const FileWatchSubscribeResponseSchema = z.object({
+    type: z.literal("file.watch.subscribe.response"),
+    payload: z.object({
+        cwd: z.string(),
+        path: z.string(),
+        ok: z.boolean(),
+        error: z.string().nullable(),
+        requestId: z.string(),
+    }),
+});
+export const FileWatchUnsubscribeResponseSchema = z.object({
+    type: z.literal("file.watch.unsubscribe.response"),
+    payload: z.object({
+        cwd: z.string(),
+        path: z.string(),
+        ok: z.boolean(),
+        error: z.string().nullable(),
+        requestId: z.string(),
+    }),
+});
+export const CodeListFilesResponseSchema = z.object({
+    type: z.literal("code.list_files.response"),
+    payload: z.object({
+        cwd: z.string(),
+        files: z.array(z.string()),
+        truncated: z.boolean(),
+        error: z.string().nullable(),
+        requestId: z.string(),
+    }),
+});
+export const CodeSymbolKindSchema = z.enum(["function", "class", "type", "variable", "property"]);
+export const CodeSymbolLocationSchema = z.object({
+    path: z.string(),
+    name: z.string(),
+    kind: CodeSymbolKindSchema,
+    line: z.number().int().positive(),
+    column: z.number().int().positive(),
+});
+export const CodeSymbolsResponseSchema = z.object({
+    type: z.literal("code.symbols.response"),
+    payload: z.object({
+        cwd: z.string(),
+        name: z.string(),
+        locations: z.array(CodeSymbolLocationSchema),
+        error: z.string().nullable(),
+        requestId: z.string(),
+    }),
+});
+export const CodeOutlineResponseSchema = z.object({
+    type: z.literal("code.outline.response"),
+    payload: z.object({
+        cwd: z.string(),
+        path: z.string(),
+        symbols: z.array(CodeSymbolLocationSchema),
+        error: z.string().nullable(),
+        requestId: z.string(),
+    }),
+});
+export const FileSearchMatchSchema = z.object({
+    /** 1-based line number. */
+    line: z.number().int().positive(),
+    /** 1-based character column of the match start within the full line. */
+    column: z.number().int().positive(),
+    /** Match length in characters. */
+    length: z.number().int().nonnegative(),
+    /** Display line (possibly truncated around the match). */
+    lineText: z.string(),
+    /** 0-based offset of the match within lineText. */
+    previewStart: z.number().int().nonnegative(),
+});
+// One event per file with matches, streamed while the scan runs.
+export const FileSearchResultEventSchema = z.object({
+    type: z.literal("file.search.result"),
+    payload: z.object({
+        cwd: z.string(),
+        searchId: z.string(),
+        path: z.string(),
+        /** File content hash at match time — the replace precondition. */
+        hash: z.string(),
+        matches: z.array(FileSearchMatchSchema),
+    }),
+});
+export const FileSearchResponseSchema = z.object({
+    type: z.literal("file.search.response"),
+    payload: z.object({
+        cwd: z.string(),
+        status: z.enum(["completed", "truncated", "superseded", "error"]),
+        error: z.string().nullable(),
+        fileCount: z.number(),
+        matchCount: z.number(),
+        requestId: z.string(),
+    }),
+});
+export const FileReplaceFileResultSchema = z.discriminatedUnion("status", [
+    z.object({
+        status: z.literal("ok"),
+        path: z.string(),
+        replacedCount: z.number(),
+        modifiedAt: z.string(),
+        hash: z.string(),
+    }),
+    // The file changed since the preview; nothing was written to it.
+    z.object({
+        status: z.literal("skipped"),
+        path: z.string(),
+        reason: z.string(),
+    }),
+    z.object({
+        status: z.literal("error"),
+        path: z.string(),
+        message: z.string(),
+    }),
+]);
+export const FileReplaceResponseSchema = z.object({
+    type: z.literal("file.replace.response"),
+    payload: z.object({
+        cwd: z.string(),
+        results: z.array(FileReplaceFileResultSchema),
+        error: z.string().nullable(),
+        requestId: z.string(),
+    }),
+});
+// Pushed to subscribers when a watched file changes under the editor. Carries
+// the fresh disk identity (null when the file is gone) so clients can ignore
+// echoes of their own saves; content is re-read on demand.
+export const FileWatchEventSchema = z.object({
+    type: z.literal("file.watch.event"),
+    payload: z.object({
+        cwd: z.string(),
+        path: z.string(),
+        change: z.enum(["changed", "deleted", "recreated"]),
+        modifiedAt: z.string().nullable(),
+        hash: z.string().nullable(),
+        size: z.number().nullable(),
+    }),
+});
+export const ListProviderModelsResponseMessageSchema = z.object({
+    type: z.literal("list_provider_models_response"),
+    payload: z.object({
+        provider: AgentProviderSchema,
+        models: z.array(AgentModelDefinitionSchema).optional(),
+        error: z.string().nullable().optional(),
+        fetchedAt: z.string(),
+        requestId: z.string(),
+    }),
+});
+export const ListProviderModesResponseMessageSchema = z.object({
+    type: z.literal("list_provider_modes_response"),
+    payload: z.object({
+        provider: AgentProviderSchema,
+        modes: z.array(AgentModeSchema).optional(),
+        error: z.string().nullable().optional(),
+        fetchedAt: z.string(),
+        requestId: z.string(),
+    }),
+});
+export const ListProviderFeaturesResponseMessageSchema = z.object({
+    type: z.literal("list_provider_features_response"),
+    payload: z.object({
+        provider: AgentProviderSchema,
+        features: z.array(AgentFeatureSchema).optional(),
+        error: z.string().nullable().optional(),
+        fetchedAt: z.string(),
+        requestId: z.string(),
+    }),
+});
+const ProviderAvailabilitySchema = z.object({
+    provider: AgentProviderSchema,
+    available: z.boolean(),
+    error: z.string().nullable().optional(),
+});
+export const ListAvailableProvidersResponseSchema = z.object({
+    type: z.literal("list_available_providers_response"),
+    payload: z.object({
+        providers: z.array(ProviderAvailabilitySchema),
+        error: z.string().nullable().optional(),
+        fetchedAt: z.string(),
+        requestId: z.string(),
+    }),
+});
+// COMPAT(providersSnapshot): added in v0.1.48, remove gating when all clients use snapshot
+export const GetProvidersSnapshotResponseMessageSchema = z.object({
+    type: z.literal("get_providers_snapshot_response"),
+    payload: z.object({
+        entries: z.array(ProviderSnapshotEntrySchema),
+        generatedAt: z.string(),
+        requestId: z.string(),
+    }),
+});
+// COMPAT(providersSnapshot): added in v0.1.48, remove gating when all clients use snapshot
+export const ProvidersSnapshotUpdateMessageSchema = z.object({
+    type: z.literal("providers_snapshot_update"),
+    payload: z.object({
+        cwd: z.string().optional(),
+        entries: z.array(ProviderSnapshotEntrySchema),
+        generatedAt: z.string(),
+    }),
+});
+// COMPAT(providersSnapshot): added in v0.1.48, remove gating when all clients use snapshot
+export const RefreshProvidersSnapshotResponseMessageSchema = z.object({
+    type: z.literal("refresh_providers_snapshot_response"),
+    payload: z.object({
+        requestId: z.string(),
+        acknowledged: z.boolean(),
+    }),
+});
+// COMPAT(providersSnapshot): added in v0.1.48, remove gating when all clients use snapshot
+export const ProviderDiagnosticResponseMessageSchema = z.object({
+    type: z.literal("provider_diagnostic_response"),
+    payload: z.object({
+        provider: AgentProviderSchema,
+        diagnostic: z.string(),
+        requestId: z.string(),
+    }),
+});
+export const ProviderUsageToneSchema = z.enum(["default", "ok", "warning", "danger"]);
+export const ProviderUsageStatusSchema = z.enum(["available", "unavailable", "error"]);
+export const ProviderUsageWindowSchema = z.object({
+    id: z.string(),
+    label: z.string(),
+    usedPct: z.number().nullable().optional(),
+    remainingPct: z.number().nullable().optional(),
+    resetsAt: z.string().nullable().optional(),
+    runsOutAt: z.string().nullable().optional(),
+    shortfallPct: z.number().nullable().optional(),
+    tone: ProviderUsageToneSchema.optional(),
+});
+export const ProviderUsageBalanceSchema = z.object({
+    id: z.string(),
+    label: z.string(),
+    used: z.number().nullable().optional(),
+    remaining: z.number().nullable().optional(),
+    limit: z.number().nullable().optional(),
+    unit: z.enum(["usd", "credits", "requests", "tokens"]),
+    resetsAt: z.string().nullable().optional(),
+    tone: ProviderUsageToneSchema.optional(),
+});
+export const ProviderUsageDetailSchema = z.object({
+    id: z.string(),
+    label: z.string(),
+    value: z.string(),
+    tone: ProviderUsageToneSchema.optional(),
+});
+export const ProviderUsageSchema = z.object({
+    providerId: z.string(),
+    displayName: z.string(),
+    status: ProviderUsageStatusSchema,
+    planLabel: z.string().nullable(),
+    sourceLabel: z.string().nullable().optional(),
+    fetchedAt: z.string().nullable().optional(),
+    nextRefreshAt: z.string().nullable().optional(),
+    windows: z.array(ProviderUsageWindowSchema),
+    balances: z.array(ProviderUsageBalanceSchema).optional(),
+    details: z.array(ProviderUsageDetailSchema).optional(),
+    error: z.string().nullable().optional(),
+});
+export const ProviderUsageListResponseMessageSchema = z.object({
+    type: z.literal("provider.usage.list.response"),
+    payload: z.object({
+        requestId: z.string(),
+        fetchedAt: z.string(),
+        providers: z.array(ProviderUsageSchema),
+    }),
+});
+export const AgentContextUsageCategorySchema = z.object({
+    /** Provider-supplied display label, e.g. "Messages", "System prompt". Not translated. */
+    name: z.string(),
+    tokens: z.number(),
+    /** Deferred content (e.g. on-demand tool schemas) is not counted in totalTokens. */
+    isDeferred: z.boolean().optional(),
+});
+export const AgentContextUsageSchema = z.object({
+    categories: z.array(AgentContextUsageCategorySchema),
+    totalTokens: z.number(),
+    maxTokens: z.number(),
+});
+export const AgentContextGetUsageResponseMessageSchema = z.object({
+    type: z.literal("agent.context.get_usage.response"),
+    payload: z.object({
+        requestId: z.string(),
+        agentId: z.string(),
+        /** Null when the agent's provider cannot report a context breakdown. */
+        usage: AgentContextUsageSchema.nullable(),
+    }),
+});
+const AgentSlashCommandSchema = z.object({
+    name: z.string(),
+    description: z.string(),
+    argumentHint: z.string(),
+    kind: z.enum(["command", "skill"]).optional().catch("command"),
+});
+export const ListCommandsResponseSchema = z.object({
+    type: z.literal("list_commands_response"),
+    payload: z.object({
+        agentId: z.string(),
+        commands: z.array(AgentSlashCommandSchema),
+        error: z.string().nullable(),
+        requestId: z.string(),
+    }),
+});
+// ============================================================================
+// Terminal Outbound Messages
+// ============================================================================
+const TerminalInfoSchema = z.object({
+    id: z.string(),
+    name: z.string(),
+    cwd: z.string(),
+    workspaceId: z.string().optional(),
+    title: z.string().optional(),
+    activity: TerminalActivitySchema.nullable().optional(),
+});
+export const TerminalCellSchema = z.object({
+    char: z.string(),
+    fg: z.number().optional(),
+    bg: z.number().optional(),
+    fgMode: z.number().optional(),
+    bgMode: z.number().optional(),
+    bold: z.boolean().optional(),
+    italic: z.boolean().optional(),
+    underline: z.boolean().optional(),
+    dim: z.boolean().optional(),
+    inverse: z.boolean().optional(),
+    strikethrough: z.boolean().optional(),
+});
+export const TerminalCursorStyleSchema = z.enum(["block", "underline", "bar"]);
+export const TerminalCursorSchema = z.object({
+    row: z.number(),
+    col: z.number(),
+    hidden: z.boolean().optional(),
+    style: TerminalCursorStyleSchema.optional(),
+    blink: z.boolean().optional(),
+});
+export const TerminalStateSchema = z.object({
+    rows: z.number(),
+    cols: z.number(),
+    grid: z.array(z.array(TerminalCellSchema)),
+    scrollback: z.array(z.array(TerminalCellSchema)),
+    cursor: TerminalCursorSchema,
+    title: z.string().optional(),
+    // Per-row soft-wrap flags aligned 1:1 with `grid` / `scrollback`. `true` means
+    // the row continued onto the next row (xterm's GRID_LINE_WRAPPED equivalent),
+    // so the client can re-wrap the logical line on resize instead of freezing it
+    // at the snapshot width. Optional: only sent to clients that advertise the
+    // `terminalReflowableSnapshot` capability, so old daemons/clients are unaffected.
+    gridWrapped: z.array(z.boolean()).optional(),
+    scrollbackWrapped: z.array(z.boolean()).optional(),
+});
+export const ListTerminalsResponseSchema = z.object({
+    type: z.literal("list_terminals_response"),
+    payload: z.object({
+        cwd: z.string().optional(),
+        terminals: z.array(TerminalInfoSchema.omit({ cwd: true })),
+        requestId: z.string(),
+    }),
+});
+export const TerminalsChangedSchema = z.object({
+    type: z.literal("terminals_changed"),
+    payload: z.object({
+        cwd: z.string(),
+        terminals: z.array(TerminalInfoSchema.omit({ cwd: true })),
+    }),
+});
+export const CreateTerminalResponseSchema = z.object({
+    type: z.literal("create_terminal_response"),
+    payload: z.object({
+        terminal: TerminalInfoSchema.nullable(),
+        error: z.string().nullable(),
+        requestId: z.string(),
+    }),
+});
+export const RenameTerminalResponseSchema = z.object({
+    type: z.literal("terminal.rename.response"),
+    payload: z.object({
+        requestId: z.string(),
+        success: z.boolean(),
+        error: z.string().nullable(),
+    }),
+});
+export const SubscribeTerminalResponseSchema = z.object({
+    type: z.literal("subscribe_terminal_response"),
+    payload: z.union([
+        z.object({
+            terminalId: z.string(),
+            slot: z.number().int().min(0).max(255),
+            error: z.null(),
+            requestId: z.string(),
+        }),
+        z.object({
+            terminalId: z.string(),
+            error: z.string(),
+            requestId: z.string(),
+        }),
+    ]),
+});
+export const KillTerminalResponseSchema = z.object({
+    type: z.literal("kill_terminal_response"),
+    payload: z.object({
+        terminalId: z.string(),
+        success: z.boolean(),
+        requestId: z.string(),
+    }),
+});
+export const CaptureTerminalResponseSchema = z.object({
+    type: z.literal("capture_terminal_response"),
+    payload: z.object({
+        terminalId: z.string(),
+        lines: z.array(z.string()),
+        totalLines: z.number().int().nonnegative(),
+        requestId: z.string(),
+    }),
+});
+export const TerminalStreamExitSchema = z.object({
+    type: z.literal("terminal_stream_exit"),
+    payload: z.object({
+        terminalId: z.string(),
+    }),
+});
+export const TerminalAttentionRequiredSchema = z.object({
+    type: z.literal("terminal_attention_required"),
+    payload: z.object({
+        serverId: z.string().optional(),
+        terminalId: z.string(),
+        cwd: z.string(),
+        workspaceId: z.string().optional(),
+        reason: z.enum(["finished", "needs_input"]),
+        title: z.string(),
+        body: z.string(),
+        shouldNotify: z.boolean(),
+    }),
+});
+export const DaemonUpdateResponseSchema = z.object({
+    type: z.literal("daemon.update.response"),
+    payload: z.object({
+        requestId: z.string(),
+        success: z.boolean(),
+        error: z.string().nullable(),
+        previousVersion: z.string().nullable(),
+        newVersion: z.string().nullable(),
+    }),
+});
+export const DaemonUpdateProgressMessageSchema = z.object({
+    type: z.literal("daemon.update.progress"),
+    payload: z.object({
+        requestId: z.string(),
+        phase: z.enum(["starting", "downloading", "installing", "complete"]),
+    }),
+});
+export const SessionOutboundMessageSchema = z.discriminatedUnion("type", [
+    BrowserAutomationExecuteRequestSchema,
+    ActivityLogMessageSchema,
+    AssistantChunkMessageSchema,
+    AudioOutputMessageSchema,
+    TranscriptionResultMessageSchema,
+    VoiceInputStateMessageSchema,
+    DictationStreamAckMessageSchema,
+    DictationStreamFinishAcceptedMessageSchema,
+    DictationStreamPartialMessageSchema,
+    DictationStreamFinalMessageSchema,
+    DictationStreamErrorMessageSchema,
+    StatusMessageSchema,
+    PongMessageSchema,
+    RpcErrorMessageSchema,
+    ArtifactMessageSchema,
+    ArtifactUpdateMessageSchema,
+    AgentUpdateMessageSchema,
+    WorkspaceUpdateMessageSchema,
+    ScriptStatusUpdateMessageSchema,
+    WorkspaceSetupProgressMessageSchema,
+    WorkspaceSetupStatusResponseMessageSchema,
+    AgentStreamMessageSchema,
+    AgentStatusMessageSchema,
+    FetchAgentsResponseMessageSchema,
+    FetchAgentHistoryResponseMessageSchema,
+    FetchRecentProviderSessionsResponseMessageSchema,
+    FetchWorkspacesResponseMessageSchema,
+    ProjectAddResponseSchema,
+    OpenProjectResponseMessageSchema,
+    StartWorkspaceScriptResponseMessageSchema,
+    LegacyListAvailableEditorsResponseMessageSchema,
+    LegacyOpenInEditorResponseMessageSchema,
+    ArchiveWorkspaceResponseMessageSchema,
+    FetchAgentResponseMessageSchema,
+    FetchAgentTimelineResponseMessageSchema,
+    AgentForkContextResponseMessageSchema,
+    CancelAgentResponseMessageSchema,
+    ClearAgentAttentionResponseMessageSchema,
+    WorkspaceCreateResponseSchema,
+    WorkspaceClearAttentionResponseSchema,
+    SendAgentMessageResponseMessageSchema,
+    SetVoiceModeResponseMessageSchema,
+    DaemonGetStatusResponseSchema,
+    DaemonGetPairingOfferResponseSchema,
+    DiagnosticsResponseSchema,
+    GetDaemonConfigResponseMessageSchema,
+    SetDaemonConfigResponseMessageSchema,
+    SpeechSettingsGetOptionsResponseSchema,
+    SpeechTtsPreviewResponseSchema,
+    AgentPersonalitiesGetStatsResponseSchema,
+    ReadProjectConfigResponseMessageSchema,
+    WriteProjectConfigResponseMessageSchema,
+    SetAgentModeResponseMessageSchema,
+    SetAgentModelResponseMessageSchema,
+    SetAgentThinkingResponseMessageSchema,
+    SetAgentFeatureResponseMessageSchema,
+    AgentDetachResponseMessageSchema,
+    AgentSubagentStopResponseMessageSchema,
+    AgentPersonalitySetResponseMessageSchema,
+    AgentRewindResponseMessageSchema,
+    UpdateAgentResponseMessageSchema,
+    ProjectRenameResponseSchema,
+    ProjectRemoveResponseSchema,
+    WorkspaceTitleSetResponseSchema,
+    WaitForFinishResponseMessageSchema,
+    AgentPermissionRequestMessageSchema,
+    AgentPermissionResolvedMessageSchema,
+    AgentDeletedMessageSchema,
+    AgentArchivedMessageSchema,
+    CloseItemsResponseSchema,
+    CheckoutStatusResponseSchema,
+    CheckoutStatusUpdateSchema,
+    SubscribeCheckoutDiffResponseSchema,
+    CheckoutDiffUpdateSchema,
+    CheckoutCommitResponseSchema,
+    CheckoutMergeResponseSchema,
+    CheckoutMergeFromBaseResponseSchema,
+    CheckoutPullResponseSchema,
+    CheckoutPushResponseSchema,
+    CheckoutRefreshResponseSchema,
+    CheckoutPrCreateResponseSchema,
+    CheckoutPrMergeResponseSchema,
+    CheckoutGithubSetAutoMergeResponseSchema,
+    CheckoutGithubGetCheckDetailsResponseSchema,
+    PreviewListConfigResponseSchema,
+    PreviewStartResponseSchema,
+    PreviewBindTabResponseSchema,
+    PreviewStopResponseSchema,
+    CheckoutPrStatusResponseSchema,
+    PullRequestTimelineResponseSchema,
+    CheckoutSwitchBranchResponseSchema,
+    CheckoutRenameBranchResponseSchema,
+    StashSaveResponseSchema,
+    StashPopResponseSchema,
+    StashListResponseSchema,
+    ValidateBranchResponseSchema,
+    BranchSuggestionsResponseSchema,
+    GitHubSearchResponseSchema,
+    HostingSearchResponseSchema,
+    HostingAuthStatusResponseSchema,
+    DirectorySuggestionsResponseSchema,
+    OttoWorktreeListResponseSchema,
+    OttoWorktreeArchiveResponseSchema,
+    CreateOttoWorktreeResponseSchema,
+    FileExplorerResponseSchema,
+    ProjectIconResponseSchema,
+    FileDownloadTokenResponseSchema,
+    FileUploadResponseSchema,
+    FileWriteResponseSchema,
+    FileWatchSubscribeResponseSchema,
+    FileWatchUnsubscribeResponseSchema,
+    FileWatchEventSchema,
+    FileSearchResultEventSchema,
+    FileSearchResponseSchema,
+    FileReplaceResponseSchema,
+    CodeListFilesResponseSchema,
+    CodeSymbolsResponseSchema,
+    CodeOutlineResponseSchema,
+    ListProviderModelsResponseMessageSchema,
+    ListProviderModesResponseMessageSchema,
+    ListProviderFeaturesResponseMessageSchema,
+    ListAvailableProvidersResponseSchema,
+    GetProvidersSnapshotResponseMessageSchema,
+    ProvidersSnapshotUpdateMessageSchema,
+    RefreshProvidersSnapshotResponseMessageSchema,
+    ProviderDiagnosticResponseMessageSchema,
+    ProviderUsageListResponseMessageSchema,
+    AgentContextGetUsageResponseMessageSchema,
+    ListCommandsResponseSchema,
+    ListTerminalsResponseSchema,
+    TerminalsChangedSchema,
+    CreateTerminalResponseSchema,
+    RenameTerminalResponseSchema,
+    SubscribeTerminalResponseSchema,
+    KillTerminalResponseSchema,
+    CaptureTerminalResponseSchema,
+    TerminalStreamExitSchema,
+    TerminalAttentionRequiredSchema,
+    ChatCreateResponseSchema,
+    ChatListResponseSchema,
+    ChatInspectResponseSchema,
+    ChatDeleteResponseSchema,
+    ChatPostResponseSchema,
+    ChatReadResponseSchema,
+    ChatWaitResponseSchema,
+    ScheduleCreateResponseSchema,
+    ScheduleListResponseSchema,
+    ScheduleInspectResponseSchema,
+    ScheduleLogsResponseSchema,
+    SchedulePauseResponseSchema,
+    ScheduleResumeResponseSchema,
+    ScheduleDeleteResponseSchema,
+    ScheduleRunOnceResponseSchema,
+    ScheduleUpdateResponseSchema,
+    LoopRunResponseSchema,
+    LoopListResponseSchema,
+    LoopInspectResponseSchema,
+    LoopLogsResponseSchema,
+    LoopStopResponseSchema,
+    DaemonUpdateProgressMessageSchema,
+    DaemonUpdateResponseSchema,
+    // COMPAT(artifacts): added in v0.4.1, drop the gate when daemon floor >= v0.4.1.
+    ArtifactListResponseSchema,
+    ArtifactCreateResponseSchema,
+    ArtifactUpdateResponseSchema,
+    ArtifactRegenerateResponseSchema,
+    ArtifactCancelResponseSchema,
+    ArtifactDeleteResponseSchema,
+    ArtifactStarResponseSchema,
+    ArtifactGetContentResponseSchema,
+    ArtifactCreatedNotificationSchema,
+    ArtifactUpdatedNotificationSchema,
+    ArtifactDeletedNotificationSchema,
+]);
+// ============================================================================
+// WebSocket Level Messages (wraps session messages)
+// ============================================================================
+// WebSocket-only messages (not session messages)
+export const WSPingMessageSchema = z.object({
+    type: z.literal("ping"),
+});
+export const WSPongMessageSchema = z.object({
+    type: z.literal("pong"),
+});
+export const WSHelloMessageSchema = z.object({
+    type: z.literal("hello"),
+    clientId: z.string().min(1),
+    clientType: z.enum(["mobile", "browser", "cli", "mcp"]),
+    protocolVersion: z.number().int(),
+    appVersion: z.string().optional(),
+    capabilities: z
+        .object({
+        voice: z.boolean().optional(),
+        pushNotifications: z.boolean().optional(),
+        [CLIENT_CAPS.reasoningMergeEnum]: z.boolean().optional(),
+        [CLIENT_CAPS.customModeIcons]: z.boolean().optional(),
+        [CLIENT_CAPS.terminalReflowableSnapshot]: z.boolean().optional(),
+        [CLIENT_CAPS.browserHost]: BrowserAutomationHostCapabilitySchema.optional(),
+    })
+        .passthrough()
+        .optional(),
+});
+export const WSRecordingStateMessageSchema = z.object({
+    type: z.literal("recording_state"),
+    isRecording: z.boolean(),
+});
+// Wrapped session message
+export const WSSessionInboundSchema = z.object({
+    type: z.literal("session"),
+    message: SessionInboundMessageSchema,
+});
+export const WSSessionOutboundSchema = z.object({
+    type: z.literal("session"),
+    message: SessionOutboundMessageSchema,
+});
+// Complete WebSocket message schemas
+export const WSInboundMessageSchema = z.discriminatedUnion("type", [
+    WSPingMessageSchema,
+    WSHelloMessageSchema,
+    WSRecordingStateMessageSchema,
+    WSSessionInboundSchema,
+]);
+export const WSOutboundMessageSchema = z.discriminatedUnion("type", [
+    WSPongMessageSchema,
+    WSSessionOutboundSchema,
+]);
+// ============================================================================
+// Helper functions for message conversion
+// ============================================================================
+/**
+ * Extract session message from WebSocket message
+ * Returns null if message should be handled at WS level only
+ */
+export function extractSessionMessage(wsMsg) {
+    if (wsMsg.type === "session") {
+        return wsMsg.message;
+    }
+    // Ping and recording_state are WS-level only
+    return null;
+}
+/**
+ * Wrap session message in WebSocket envelope
+ */
+export function wrapSessionMessage(sessionMsg) {
+    return {
+        type: "session",
+        message: sessionMsg,
+    };
+}
+export function parseServerInfoStatusPayload(payload) {
+    const parsed = ServerInfoStatusPayloadSchema.safeParse(payload);
+    if (!parsed.success) {
+        return null;
+    }
+    return parsed.data;
+}
+//# sourceMappingURL=messages.js.map