@getpaseo/server 0.1.12 → 0.1.14

package/dist/server/shared/messages.js

@@ -1,6 +1,6 @@
-import { z } from "zod";
-import { AGENT_LIFECYCLE_STATUSES } from "./agent-lifecycle.js";
-import { AgentProviderSchema } from "../server/agent/provider-manifest.js";
+import { z } from 'zod';
+import { AGENT_LIFECYCLE_STATUSES } from './agent-lifecycle.js';
+import { AgentProviderSchema } from '../server/agent/provider-manifest.js';
 export const AgentStatusSchema = z.enum(AGENT_LIFECYCLE_STATUSES);
 const AgentModeSchema = z.object({
     id: z.string(),
@@ -39,22 +39,22 @@ const AgentUsageSchema = z.object({
     totalCostUsd: z.number().optional(),
 });
 const McpStdioServerConfigSchema = z.object({
-    type: z.literal("stdio"),
+    type: z.literal('stdio'),
     command: z.string(),
     args: z.array(z.string()).optional(),
     env: z.record(z.string()).optional(),
 });
 const McpHttpServerConfigSchema = z.object({
-    type: z.literal("http"),
+    type: z.literal('http'),
     url: z.string(),
     headers: z.record(z.string()).optional(),
 });
 const McpSseServerConfigSchema = z.object({
-    type: z.literal("sse"),
+    type: z.literal('sse'),
     url: z.string(),
     headers: z.record(z.string()).optional(),
 });
-const McpServerConfigSchema = z.discriminatedUnion("type", [
+const McpServerConfigSchema = z.discriminatedUnion('type', [
     McpStdioServerConfigSchema,
     McpHttpServerConfigSchema,
     McpSseServerConfigSchema,
@@ -65,13 +65,7 @@ const AgentSessionConfigSchema = z.object({
     modeId: z.string().optional(),
     model: z.string().optional(),
     thinkingOptionId: z.string().optional(),
-    title: z
-        .string()
-        .trim()
-        .min(1)
-        .max(40)
-        .optional()
-        .nullable(),
+    title: z.string().trim().min(1).max(40).optional().nullable(),
     approvalPolicy: z.string().optional(),
     sandboxMode: z.string().optional(),
     networkAccess: z.boolean().optional(),
@@ -89,12 +83,12 @@ const AgentSessionConfigSchema = z.object({
 const AgentPermissionUpdateSchema = z.record(z.unknown());
 export const AgentPermissionResponseSchema = z.union([
     z.object({
-        behavior: z.literal("allow"),
+        behavior: z.literal('allow'),
         updatedInput: z.record(z.unknown()).optional(),
         updatedPermissions: z.array(AgentPermissionUpdateSchema).optional(),
     }),
     z.object({
-        behavior: z.literal("deny"),
+        behavior: z.literal('deny'),
         message: z.string().optional(),
         interrupt: z.boolean().optional(),
     }),
@@ -103,7 +97,7 @@ export const AgentPermissionRequestPayloadSchema = z.object({
     id: z.string(),
     provider: AgentProviderSchema,
     name: z.string(),
-    kind: z.enum(["tool", "plan", "question", "mode", "other"]),
+    kind: z.enum(['tool', 'plan', 'question', 'mode', 'other']),
     title: z.string().optional(),
     description: z.string().optional(),
     input: z.record(z.unknown()).optional(),
@@ -125,39 +119,39 @@ const NonNullUnknownSchema = z.union([
     z.array(z.unknown()),
     z.object({}).passthrough(),
 ]);
-const ToolCallDetailPayloadSchema = z.discriminatedUnion("type", [
+const ToolCallDetailPayloadSchema = z.discriminatedUnion('type', [
     z.object({
-        type: z.literal("shell"),
+        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"),
+        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"),
+        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"),
+        type: z.literal('write'),
         filePath: z.string(),
         content: z.string().optional(),
     }),
     z.object({
-        type: z.literal("search"),
+        type: z.literal('search'),
         query: z.string(),
     }),
     z.object({
-        type: z.literal("worktree_setup"),
+        type: z.literal('worktree_setup'),
         worktreePath: z.string(),
         branchName: z.string(),
         log: z.string(),
@@ -165,39 +159,41 @@ const ToolCallDetailPayloadSchema = z.discriminatedUnion("type", [
             index: z.number().int().positive(),
             command: z.string(),
             cwd: z.string(),
-            status: z.enum(["running", "completed", "failed"]),
+            status: z.enum(['running', 'completed', 'failed']),
             exitCode: z.number().nullable(),
             durationMs: z.number().nonnegative().optional(),
         })),
         truncated: z.boolean().optional(),
     }),
     z.object({
-        type: z.literal("unknown"),
+        type: z.literal('unknown'),
         input: UnknownValueSchema,
         output: UnknownValueSchema,
     }),
 ]);
-const ToolCallBasePayloadSchema = z.object({
-    type: z.literal("tool_call"),
+const ToolCallBasePayloadSchema = z
+    .object({
+    type: z.literal('tool_call'),
     callId: z.string(),
     name: z.string(),
     detail: ToolCallDetailPayloadSchema,
     metadata: z.record(z.unknown()).optional(),
-}).strict();
+})
+    .strict();
 const ToolCallRunningPayloadSchema = ToolCallBasePayloadSchema.extend({
-    status: z.literal("running"),
+    status: z.literal('running'),
     error: z.null(),
 });
 const ToolCallCompletedPayloadSchema = ToolCallBasePayloadSchema.extend({
-    status: z.literal("completed"),
+    status: z.literal('completed'),
     error: z.null(),
 });
 const ToolCallFailedPayloadSchema = ToolCallBasePayloadSchema.extend({
-    status: z.literal("failed"),
+    status: z.literal('failed'),
     error: NonNullUnknownSchema,
 });
 const ToolCallCanceledPayloadSchema = ToolCallBasePayloadSchema.extend({
-    status: z.literal("canceled"),
+    status: z.literal('canceled'),
     error: z.null(),
 });
 const ToolCallTimelineItemPayloadSchema = z.union([
@@ -208,84 +204,95 @@ const ToolCallTimelineItemPayloadSchema = z.union([
 ]);
 export const AgentTimelineItemPayloadSchema = z.union([
     z.object({
-        type: z.literal("user_message"),
+        type: z.literal('user_message'),
         text: z.string(),
         messageId: z.string().optional(),
     }),
     z.object({
-        type: z.literal("assistant_message"),
+        type: z.literal('assistant_message'),
         text: z.string(),
     }),
     z.object({
-        type: z.literal("reasoning"),
+        type: z.literal('reasoning'),
         text: z.string(),
     }),
     ToolCallTimelineItemPayloadSchema,
     z.object({
-        type: z.literal("todo"),
+        type: z.literal('todo'),
         items: z.array(z.object({
             text: z.string(),
             completed: z.boolean(),
         })),
     }),
     z.object({
-        type: z.literal("error"),
+        type: z.literal('error'),
         message: z.string(),
     }),
     z.object({
-        type: z.literal("compaction"),
-        status: z.enum(["loading", "completed"]),
-        trigger: z.enum(["auto", "manual"]).optional(),
+        type: z.literal('compaction'),
+        status: z.enum(['loading', 'completed']),
+        trigger: z.enum(['auto', 'manual']).optional(),
         preTokens: z.number().optional(),
     }),
 ]);
-export const AgentStreamEventPayloadSchema = z.discriminatedUnion("type", [
+export const AgentStreamEventPayloadSchema = z.discriminatedUnion('type', [
     z.object({
-        type: z.literal("thread_started"),
+        type: z.literal('thread_started'),
         sessionId: z.string(),
         provider: AgentProviderSchema,
     }),
     z.object({
-        type: z.literal("turn_started"),
+        type: z.literal('turn_started'),
         provider: AgentProviderSchema,
     }),
     z.object({
-        type: z.literal("turn_completed"),
+        type: z.literal('turn_completed'),
         provider: AgentProviderSchema,
         usage: AgentUsageSchema.optional(),
     }),
     z.object({
-        type: z.literal("turn_failed"),
+        type: z.literal('turn_failed'),
         provider: AgentProviderSchema,
         error: z.string(),
     }),
     z.object({
-        type: z.literal("turn_canceled"),
+        type: z.literal('turn_canceled'),
         provider: AgentProviderSchema,
         reason: z.string(),
     }),
     z.object({
-        type: z.literal("timeline"),
+        type: z.literal('timeline'),
         provider: AgentProviderSchema,
         item: AgentTimelineItemPayloadSchema,
     }),
     z.object({
-        type: z.literal("permission_requested"),
+        type: z.literal('permission_requested'),
         provider: AgentProviderSchema,
         request: AgentPermissionRequestPayloadSchema,
     }),
     z.object({
-        type: z.literal("permission_resolved"),
+        type: z.literal('permission_resolved'),
         provider: AgentProviderSchema,
         requestId: z.string(),
         resolution: AgentPermissionResponseSchema,
     }),
     z.object({
-        type: z.literal("attention_required"),
+        type: z.literal('attention_required'),
         provider: AgentProviderSchema,
-        reason: z.enum(["finished", "error", "permission"]),
+        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
@@ -324,7 +331,7 @@ export const AgentSnapshotPayloadSchema = z.object({
     title: z.string().nullable(),
     labels: z.record(z.string()).default({}),
     requiresAttention: z.boolean().optional(),
-    attentionReason: z.enum(["finished", "error", "permission"]).nullable().optional(),
+    attentionReason: z.enum(['finished', 'error', 'permission']).nullable().optional(),
     attentionTimestamp: z.string().nullable().optional(),
     archivedAt: z.string().nullable().optional(),
 });
@@ -332,89 +339,71 @@ export const AgentSnapshotPayloadSchema = z.object({
 // Session Inbound Messages (Session receives these)
 // ============================================================================
 export const VoiceAudioChunkMessageSchema = z.object({
-    type: z.literal("voice_audio_chunk"),
+    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"),
+    type: z.literal('abort_request'),
 });
 export const AudioPlayedMessageSchema = z.object({
-    type: z.literal("audio_played"),
+    type: z.literal('audio_played'),
     id: z.string(),
 });
-export const RequestAgentListMessageSchema = z.object({
-    type: z.literal("request_agent_list"),
-    requestId: z.string(),
-    filter: z.object({
-        labels: z.record(z.string()).optional(),
-    }).optional(),
-});
-export const SubscribeAgentUpdatesMessageSchema = z.object({
-    type: z.literal("subscribe_agent_updates"),
-    subscriptionId: z.string(),
-    filter: z.object({
-        labels: z.record(z.string()).optional(),
-        agentId: z.string().optional(),
-    }).optional(),
-});
-export const UnsubscribeAgentUpdatesMessageSchema = z.object({
-    type: z.literal("unsubscribe_agent_updates"),
-    subscriptionId: z.string(),
+const AgentDirectoryFilterSchema = z.object({
+    labels: z.record(z.string()).optional(),
+    projectKeys: z.array(z.string()).optional(),
+    statuses: z.array(AgentStatusSchema).optional(),
+    includeArchived: z.boolean().optional(),
+    requiresAttention: z.boolean().optional(),
 });
 export const DeleteAgentRequestMessageSchema = z.object({
-    type: z.literal("delete_agent_request"),
+    type: z.literal('delete_agent_request'),
     agentId: z.string(),
     requestId: z.string(),
 });
 export const ArchiveAgentRequestMessageSchema = z.object({
-    type: z.literal("archive_agent_request"),
+    type: z.literal('archive_agent_request'),
     agentId: z.string(),
     requestId: z.string(),
 });
 export const UpdateAgentRequestMessageSchema = z.object({
-    type: z.literal("update_agent_request"),
+    type: z.literal('update_agent_request'),
     agentId: z.string(),
     name: z.string().optional(),
     labels: z.record(z.string()).optional(),
     requestId: z.string(),
 });
 export const SetVoiceModeMessageSchema = z.object({
-    type: z.literal("set_voice_mode"),
+    type: z.literal('set_voice_mode'),
     enabled: z.boolean(),
     agentId: z.string().optional(),
     requestId: z.string().optional(),
 });
 export const SendAgentMessageSchema = z.object({
-    type: z.literal("send_agent_message"),
+    type: z.literal('send_agent_message'),
     agentId: z.string(),
     text: z.string(),
     messageId: z.string().optional(), // Client-provided ID for deduplication
-    images: z.array(z.object({
+    images: z
+        .array(z.object({
         data: z.string(), // base64 encoded image
         mimeType: z.string(), // e.g., "image/jpeg", "image/png"
-    })).optional(),
+    }))
+        .optional(),
 });
 // ============================================================================
 // Agent RPCs (requestId-correlated)
 // ============================================================================
 export const FetchAgentsRequestMessageSchema = z.object({
-    type: z.literal("fetch_agents_request"),
+    type: z.literal('fetch_agents_request'),
     requestId: z.string(),
-    filter: z
-        .object({
-        labels: z.record(z.string()).optional(),
-        projectKeys: z.array(z.string()).optional(),
-        statuses: z.array(AgentStatusSchema).optional(),
-        includeArchived: z.boolean().optional(),
-        requiresAttention: z.boolean().optional(),
-    })
-        .optional(),
+    filter: AgentDirectoryFilterSchema.optional(),
     sort: z
         .array(z.object({
-        key: z.enum(["status_priority", "created_at", "updated_at", "title"]),
-        direction: z.enum(["asc", "desc"]),
+        key: z.enum(['status_priority', 'created_at', 'updated_at', 'title']),
+        direction: z.enum(['asc', 'desc']),
     }))
         .optional(),
     page: z
@@ -423,15 +412,20 @@ export const FetchAgentsRequestMessageSchema = z.object({
         cursor: z.string().min(1).optional(),
     })
         .optional(),
+    subscribe: z
+        .object({
+        subscriptionId: z.string().optional(),
+    })
+        .optional(),
 });
 export const FetchAgentRequestMessageSchema = z.object({
-    type: z.literal("fetch_agent_request"),
+    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"),
+    type: z.literal('send_agent_message_request'),
     requestId: z.string(),
     /** Accepts full ID, unique prefix, or exact full title (server resolves). */
     agentId: z.string(),
@@ -445,7 +439,7 @@ export const SendAgentMessageRequestSchema = z.object({
         .optional(),
 });
 export const WaitForFinishRequestSchema = z.object({
-    type: z.literal("wait_for_finish_request"),
+    type: z.literal('wait_for_finish_request'),
     requestId: z.string(),
     /** Accepts full ID, unique prefix, or exact full title (server resolves). */
     agentId: z.string(),
@@ -455,24 +449,24 @@ export const WaitForFinishRequestSchema = z.object({
 // Dictation Streaming (lossless, resumable)
 // ============================================================================
 export const DictationStreamStartMessageSchema = z.object({
-    type: z.literal("dictation_stream_start"),
+    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"),
+    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"),
+    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"),
+    type: z.literal('dictation_stream_cancel'),
     dictationId: z.string(),
 });
 const GitSetupOptionsSchema = z.object({
@@ -483,55 +477,57 @@ const GitSetupOptionsSchema = z.object({
     worktreeSlug: z.string().optional(),
 });
 export const CreateAgentRequestMessageSchema = z.object({
-    type: z.literal("create_agent_request"),
+    type: z.literal('create_agent_request'),
     config: AgentSessionConfigSchema,
     worktreeName: z.string().optional(),
     initialPrompt: z.string().optional(),
     outputSchema: z.record(z.unknown()).optional(),
-    images: z.array(z.object({
+    images: z
+        .array(z.object({
         data: z.string(), // base64 encoded image
         mimeType: z.string(), // e.g., "image/jpeg", "image/png"
-    })).optional(),
+    }))
+        .optional(),
     git: GitSetupOptionsSchema.optional(),
     labels: z.record(z.string()).default({}),
     requestId: z.string(),
 });
 export const ListProviderModelsRequestMessageSchema = z.object({
-    type: z.literal("list_provider_models_request"),
+    type: z.literal('list_provider_models_request'),
     provider: AgentProviderSchema,
     cwd: z.string().optional(),
     requestId: z.string(),
 });
 export const ListAvailableProvidersRequestMessageSchema = z.object({
-    type: z.literal("list_available_providers_request"),
+    type: z.literal('list_available_providers_request'),
     requestId: z.string(),
 });
 export const SpeechModelsListRequestSchema = z.object({
-    type: z.literal("speech_models_list_request"),
+    type: z.literal('speech_models_list_request'),
     requestId: z.string(),
 });
 export const SpeechModelsDownloadRequestSchema = z.object({
-    type: z.literal("speech_models_download_request"),
+    type: z.literal('speech_models_download_request'),
     modelIds: z.array(z.string()).optional(),
     requestId: z.string(),
 });
 export const ResumeAgentRequestMessageSchema = z.object({
-    type: z.literal("resume_agent_request"),
+    type: z.literal('resume_agent_request'),
     handle: AgentPersistenceHandleSchema,
     overrides: AgentSessionConfigSchema.partial().optional(),
     requestId: z.string(),
 });
 export const RefreshAgentRequestMessageSchema = z.object({
-    type: z.literal("refresh_agent_request"),
+    type: z.literal('refresh_agent_request'),
     agentId: z.string(),
     requestId: z.string(),
 });
 export const CancelAgentRequestMessageSchema = z.object({
-    type: z.literal("cancel_agent_request"),
+    type: z.literal('cancel_agent_request'),
     agentId: z.string(),
 });
 export const RestartServerRequestMessageSchema = z.object({
-    type: z.literal("restart_server_request"),
+    type: z.literal('restart_server_request'),
     reason: z.string().optional(),
     requestId: z.string(),
 });
@@ -540,24 +536,24 @@ export const AgentTimelineCursorSchema = z.object({
     seq: z.number().int().nonnegative(),
 });
 export const FetchAgentTimelineRequestMessageSchema = z.object({
-    type: z.literal("fetch_agent_timeline_request"),
+    type: z.literal('fetch_agent_timeline_request'),
     agentId: z.string(),
     requestId: z.string(),
-    direction: z.enum(["tail", "before", "after"]).optional(),
+    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(),
+    projection: z.enum(['projected', 'canonical']).optional(),
 });
 export const SetAgentModeRequestMessageSchema = z.object({
-    type: z.literal("set_agent_mode_request"),
+    type: z.literal('set_agent_mode_request'),
     agentId: z.string(),
     modeId: z.string(),
     requestId: z.string(),
 });
 export const SetAgentModeResponseMessageSchema = z.object({
-    type: z.literal("set_agent_mode_response"),
+    type: z.literal('set_agent_mode_response'),
     payload: z.object({
         requestId: z.string(),
         agentId: z.string(),
@@ -566,13 +562,13 @@ export const SetAgentModeResponseMessageSchema = z.object({
     }),
 });
 export const SetAgentModelRequestMessageSchema = z.object({
-    type: z.literal("set_agent_model_request"),
+    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"),
+    type: z.literal('set_agent_model_response'),
     payload: z.object({
         requestId: z.string(),
         agentId: z.string(),
@@ -581,13 +577,13 @@ export const SetAgentModelResponseMessageSchema = z.object({
     }),
 });
 export const SetAgentThinkingRequestMessageSchema = z.object({
-    type: z.literal("set_agent_thinking_request"),
+    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"),
+    type: z.literal('set_agent_thinking_response'),
     payload: z.object({
         requestId: z.string(),
         agentId: z.string(),
@@ -596,7 +592,7 @@ export const SetAgentThinkingResponseMessageSchema = z.object({
     }),
 });
 export const UpdateAgentResponseMessageSchema = z.object({
-    type: z.literal("update_agent_response"),
+    type: z.literal('update_agent_response'),
     payload: z.object({
         requestId: z.string(),
         agentId: z.string(),
@@ -605,7 +601,7 @@ export const UpdateAgentResponseMessageSchema = z.object({
     }),
 });
 export const SetVoiceModeResponseMessageSchema = z.object({
-    type: z.literal("set_voice_mode_response"),
+    type: z.literal('set_voice_mode_response'),
     payload: z.object({
         requestId: z.string(),
         enabled: z.boolean(),
@@ -618,70 +614,65 @@ export const SetVoiceModeResponseMessageSchema = z.object({
     }),
 });
 export const AgentPermissionResponseMessageSchema = z.object({
-    type: z.literal("agent_permission_response"),
+    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 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"]),
+    mode: z.enum(['uncommitted', 'base']),
     baseRef: z.string().optional(),
 });
 export const CheckoutStatusRequestSchema = z.object({
-    type: z.literal("checkout_status_request"),
+    type: z.literal('checkout_status_request'),
     cwd: z.string(),
     requestId: z.string(),
 });
 export const SubscribeCheckoutDiffRequestSchema = z.object({
-    type: z.literal("subscribe_checkout_diff_request"),
+    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"),
+    type: z.literal('unsubscribe_checkout_diff_request'),
     subscriptionId: z.string(),
 });
 export const CheckoutCommitRequestSchema = z.object({
-    type: z.literal("checkout_commit_request"),
+    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"),
+    type: z.literal('checkout_merge_request'),
     cwd: z.string(),
     baseRef: z.string().optional(),
-    strategy: z.enum(["merge", "squash"]).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"),
+    type: z.literal('checkout_merge_from_base_request'),
     cwd: z.string(),
     baseRef: z.string().optional(),
     requireCleanTarget: z.boolean().optional(),
     requestId: z.string(),
 });
 export const CheckoutPushRequestSchema = z.object({
-    type: z.literal("checkout_push_request"),
+    type: z.literal('checkout_push_request'),
     cwd: z.string(),
     requestId: z.string(),
 });
 export const CheckoutPrCreateRequestSchema = z.object({
-    type: z.literal("checkout_pr_create_request"),
+    type: z.literal('checkout_pr_create_request'),
     cwd: z.string(),
     title: z.string().optional(),
     body: z.string().optional(),
@@ -689,37 +680,40 @@ export const CheckoutPrCreateRequestSchema = z.object({
     requestId: z.string(),
 });
 export const CheckoutPrStatusRequestSchema = z.object({
-    type: z.literal("checkout_pr_status_request"),
+    type: z.literal('checkout_pr_status_request'),
     cwd: z.string(),
     requestId: z.string(),
 });
 export const ValidateBranchRequestSchema = z.object({
-    type: z.literal("validate_branch_request"),
+    type: z.literal('validate_branch_request'),
     cwd: z.string(),
     branchName: z.string(),
     requestId: z.string(),
 });
 export const BranchSuggestionsRequestSchema = z.object({
-    type: z.literal("branch_suggestions_request"),
+    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 DirectorySuggestionsRequestSchema = z.object({
-    type: z.literal("directory_suggestions_request"),
+    type: z.literal('directory_suggestions_request'),
     query: z.string(),
+    cwd: z.string().optional(),
+    includeFiles: z.boolean().optional(),
+    includeDirectories: z.boolean().optional(),
     limit: z.number().int().min(1).max(100).optional(),
     requestId: z.string(),
 });
 export const PaseoWorktreeListRequestSchema = z.object({
-    type: z.literal("paseo_worktree_list_request"),
+    type: z.literal('paseo_worktree_list_request'),
     cwd: z.string().optional(),
     repoRoot: z.string().optional(),
     requestId: z.string(),
 });
 export const PaseoWorktreeArchiveRequestSchema = z.object({
-    type: z.literal("paseo_worktree_archive_request"),
+    type: z.literal('paseo_worktree_archive_request'),
     worktreePath: z.string().optional(),
     repoRoot: z.string().optional(),
     branchName: z.string().optional(),
@@ -732,7 +726,7 @@ const HighlightTokenSchema = z.object({
     style: z.string().nullable(),
 });
 const DiffLineSchema = z.object({
-    type: z.enum(["add", "remove", "context", "header"]),
+    type: z.enum(['add', 'remove', 'context', 'header']),
     content: z.string(),
     tokens: z.array(HighlightTokenSchema).optional(),
 });
@@ -750,19 +744,19 @@ const ParsedDiffFileSchema = z.object({
     additions: z.number(),
     deletions: z.number(),
     hunks: z.array(DiffHunkSchema),
-    status: z.enum(["ok", "too_large", "binary"]).optional(),
+    status: z.enum(['ok', 'too_large', 'binary']).optional(),
 });
 const FileExplorerEntrySchema = z.object({
     name: z.string(),
     path: z.string(),
-    kind: z.enum(["file", "directory"]),
+    kind: z.enum(['file', 'directory']),
     size: z.number(),
     modifiedAt: z.string(),
 });
 const FileExplorerFileSchema = z.object({
     path: z.string(),
-    kind: z.enum(["text", "image", "binary"]),
-    encoding: z.enum(["utf-8", "base64", "none"]),
+    kind: z.enum(['text', 'image', 'binary']),
+    encoding: z.enum(['utf-8', 'base64', 'none']),
     content: z.string().optional(),
     mimeType: z.string().optional(),
     size: z.number(),
@@ -773,110 +767,111 @@ const FileExplorerDirectorySchema = z.object({
     entries: z.array(FileExplorerEntrySchema),
 });
 export const FileExplorerRequestSchema = z.object({
-    type: z.literal("file_explorer_request"),
+    type: z.literal('file_explorer_request'),
     agentId: z.string(),
     path: z.string().optional(),
-    mode: z.enum(["list", "file"]),
+    mode: z.enum(['list', 'file']),
     requestId: z.string(),
 });
 export const ProjectIconRequestSchema = z.object({
-    type: z.literal("project_icon_request"),
+    type: z.literal('project_icon_request'),
     cwd: z.string(),
     requestId: z.string(),
 });
 export const FileDownloadTokenRequestSchema = z.object({
-    type: z.literal("file_download_token_request"),
+    type: z.literal('file_download_token_request'),
     agentId: z.string(),
     path: z.string(),
     requestId: z.string(),
 });
 export const ClearAgentAttentionMessageSchema = z.object({
-    type: z.literal("clear_agent_attention"),
+    type: z.literal('clear_agent_attention'),
     agentId: z.union([z.string(), z.array(z.string())]),
 });
 export const ClientHeartbeatMessageSchema = z.object({
-    type: z.literal("client_heartbeat"),
-    deviceType: z.enum(["web", "mobile"]),
+    type: z.literal('client_heartbeat'),
+    deviceType: z.enum(['web', 'mobile']),
     focusedAgentId: z.string().nullable(),
     lastActivityAt: z.string(),
     appVisible: z.boolean(),
     appVisibilityChangedAt: z.string().optional(),
 });
 export const PingMessageSchema = z.object({
-    type: z.literal("ping"),
+    type: z.literal('ping'),
     requestId: z.string(),
     clientSentAt: z.number().int().optional(),
 });
-export const ListCommandsRequestSchema = z.object({
-    type: z.literal("list_commands_request"),
-    agentId: z.string(),
-    requestId: z.string(),
+const ListCommandsDraftConfigSchema = z.object({
+    provider: AgentProviderSchema,
+    cwd: z.string(),
+    modeId: z.string().optional(),
+    model: z.string().optional(),
+    thinkingOptionId: z.string().optional(),
 });
-export const ExecuteCommandRequestSchema = z.object({
-    type: z.literal("execute_command_request"),
+export const ListCommandsRequestSchema = z.object({
+    type: z.literal('list_commands_request'),
     agentId: z.string(),
-    commandName: z.string(),
-    args: z.string().optional(),
+    draftConfig: ListCommandsDraftConfigSchema.optional(),
     requestId: z.string(),
 });
 export const RegisterPushTokenMessageSchema = z.object({
-    type: z.literal("register_push_token"),
+    type: z.literal('register_push_token'),
     token: z.string(),
 });
 // ============================================================================
 // Terminal Messages
 // ============================================================================
 export const ListTerminalsRequestSchema = z.object({
-    type: z.literal("list_terminals_request"),
+    type: z.literal('list_terminals_request'),
     cwd: z.string(),
     requestId: z.string(),
 });
 export const SubscribeTerminalsRequestSchema = z.object({
-    type: z.literal("subscribe_terminals_request"),
+    type: z.literal('subscribe_terminals_request'),
     cwd: z.string(),
 });
 export const UnsubscribeTerminalsRequestSchema = z.object({
-    type: z.literal("unsubscribe_terminals_request"),
+    type: z.literal('unsubscribe_terminals_request'),
     cwd: z.string(),
 });
 export const CreateTerminalRequestSchema = z.object({
-    type: z.literal("create_terminal_request"),
+    type: z.literal('create_terminal_request'),
     cwd: z.string(),
     name: z.string().optional(),
     requestId: z.string(),
 });
 export const SubscribeTerminalRequestSchema = z.object({
-    type: z.literal("subscribe_terminal_request"),
+    type: z.literal('subscribe_terminal_request'),
     terminalId: z.string(),
     requestId: z.string(),
 });
 export const UnsubscribeTerminalRequestSchema = z.object({
-    type: z.literal("unsubscribe_terminal_request"),
+    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() }),
+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"),
+        type: z.literal('mouse'),
         row: z.number(),
         col: z.number(),
         button: z.number(),
-        action: z.enum(["down", "up", "move"]),
+        action: z.enum(['down', 'up', 'move']),
     }),
 ]);
 export const TerminalInputSchema = z.object({
-    type: z.literal("terminal_input"),
+    type: z.literal('terminal_input'),
     terminalId: z.string(),
     message: TerminalClientMessageSchema,
 });
 export const KillTerminalRequestSchema = z.object({
-    type: z.literal("kill_terminal_request"),
+    type: z.literal('kill_terminal_request'),
     terminalId: z.string(),
     requestId: z.string(),
 });
 export const AttachTerminalStreamRequestSchema = z.object({
-    type: z.literal("attach_terminal_stream_request"),
+    type: z.literal('attach_terminal_stream_request'),
     terminalId: z.string(),
     resumeOffset: z.number().int().nonnegative().optional(),
     rows: z.number().int().positive().optional(),
@@ -884,18 +879,16 @@ export const AttachTerminalStreamRequestSchema = z.object({
     requestId: z.string(),
 });
 export const DetachTerminalStreamRequestSchema = z.object({
-    type: z.literal("detach_terminal_stream_request"),
+    type: z.literal('detach_terminal_stream_request'),
     streamId: z.number().int().nonnegative(),
     requestId: z.string(),
 });
-export const SessionInboundMessageSchema = z.discriminatedUnion("type", [
+export const SessionInboundMessageSchema = z.discriminatedUnion('type', [
     VoiceAudioChunkMessageSchema,
     AbortRequestMessageSchema,
     AudioPlayedMessageSchema,
     FetchAgentsRequestMessageSchema,
     FetchAgentRequestMessageSchema,
-    SubscribeAgentUpdatesMessageSchema,
-    UnsubscribeAgentUpdatesMessageSchema,
     DeleteAgentRequestMessageSchema,
     ArchiveAgentRequestMessageSchema,
     UpdateAgentRequestMessageSchema,
@@ -941,7 +934,6 @@ export const SessionInboundMessageSchema = z.discriminatedUnion("type", [
     ClientHeartbeatMessageSchema,
     PingMessageSchema,
     ListCommandsRequestSchema,
-    ExecuteCommandRequestSchema,
     RegisterPushTokenMessageSchema,
     ListTerminalsRequestSchema,
     SubscribeTerminalsRequestSchema,
@@ -960,29 +952,22 @@ export const SessionInboundMessageSchema = z.discriminatedUnion("type", [
 export const ActivityLogPayloadSchema = z.object({
     id: z.string(),
     timestamp: z.coerce.date(),
-    type: z.enum([
-        "transcript",
-        "assistant",
-        "tool_call",
-        "tool_result",
-        "error",
-        "system",
-    ]),
+    type: z.enum(['transcript', 'assistant', 'tool_call', 'tool_result', 'error', 'system']),
     content: z.string(),
     metadata: z.record(z.unknown()).optional(),
 });
 export const ActivityLogMessageSchema = z.object({
-    type: z.literal("activity_log"),
+    type: z.literal('activity_log'),
     payload: ActivityLogPayloadSchema,
 });
 export const AssistantChunkMessageSchema = z.object({
-    type: z.literal("assistant_chunk"),
+    type: z.literal('assistant_chunk'),
     payload: z.object({
         chunk: z.string(),
     }),
 });
 export const AudioOutputMessageSchema = z.object({
-    type: z.literal("audio_output"),
+    type: z.literal('audio_output'),
     payload: z.object({
         audio: z.string(), // base64 encoded
         format: z.string(),
@@ -994,7 +979,7 @@ export const AudioOutputMessageSchema = z.object({
     }),
 });
 export const TranscriptionResultMessageSchema = z.object({
-    type: z.literal("transcription_result"),
+    type: z.literal('transcription_result'),
     payload: z.object({
         text: z.string(),
         language: z.string().optional(),
@@ -1008,28 +993,28 @@ export const TranscriptionResultMessageSchema = z.object({
     }),
 });
 export const DictationStreamAckMessageSchema = z.object({
-    type: z.literal("dictation_stream_ack"),
+    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"),
+    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"),
+    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"),
+    type: z.literal('dictation_stream_final'),
     payload: z.object({
         dictationId: z.string(),
         text: z.string(),
@@ -1037,7 +1022,7 @@ export const DictationStreamFinalMessageSchema = z.object({
     }),
 });
 export const DictationStreamErrorMessageSchema = z.object({
-    type: z.literal("dictation_stream_error"),
+    type: z.literal('dictation_stream_error'),
     payload: z.object({
         dictationId: z.string(),
         error: z.string(),
@@ -1060,10 +1045,15 @@ export const ServerCapabilitiesSchema = z
     voice: ServerVoiceCapabilitiesSchema.optional(),
 })
     .passthrough();
-const ServerInfoHostnameSchema = z
-    .unknown()
-    .transform((value) => {
-    if (typeof value !== "string") {
+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();
@@ -1084,18 +1074,20 @@ const ServerCapabilitiesFromUnknownSchema = z
 });
 export const ServerInfoStatusPayloadSchema = z
     .object({
-    status: z.literal("server_info"),
+    status: z.literal('server_info'),
     serverId: z.string().trim().min(1),
     hostname: ServerInfoHostnameSchema.optional(),
+    version: ServerInfoVersionSchema.optional(),
     capabilities: ServerCapabilitiesFromUnknownSchema,
 })
     .passthrough()
     .transform((payload) => ({
     ...payload,
     hostname: payload.hostname ?? null,
+    version: payload.version ?? null,
 }));
 export const StatusMessageSchema = z.object({
-    type: z.literal("status"),
+    type: z.literal('status'),
     payload: z
         .object({
         status: z.string(),
@@ -1103,7 +1095,7 @@ export const StatusMessageSchema = z.object({
         .passthrough(), // Allow additional fields
 });
 export const PongMessageSchema = z.object({
-    type: z.literal("pong"),
+    type: z.literal('pong'),
     payload: z.object({
         requestId: z.string(),
         clientSentAt: z.number().int().optional(),
@@ -1112,7 +1104,7 @@ export const PongMessageSchema = z.object({
     }),
 });
 export const RpcErrorMessageSchema = z.object({
-    type: z.literal("rpc_error"),
+    type: z.literal('rpc_error'),
     payload: z.object({
         requestId: z.string(),
         requestType: z.string().optional(),
@@ -1129,33 +1121,33 @@ const AgentStatusWithTimelineSchema = AgentStatusWithRequestSchema.extend({
 });
 export const AgentCreatedStatusPayloadSchema = z
     .object({
-    status: z.literal("agent_created"),
+    status: z.literal('agent_created'),
     agent: AgentSnapshotPayloadSchema,
 })
     .extend(AgentStatusWithRequestSchema.shape);
 export const AgentCreateFailedStatusPayloadSchema = z.object({
-    status: z.literal("agent_create_failed"),
+    status: z.literal('agent_create_failed'),
     requestId: z.string(),
     error: z.string(),
 });
 export const AgentResumedStatusPayloadSchema = z
     .object({
-    status: z.literal("agent_resumed"),
+    status: z.literal('agent_resumed'),
     agent: AgentSnapshotPayloadSchema,
 })
     .extend(AgentStatusWithTimelineSchema.shape);
 export const AgentRefreshedStatusPayloadSchema = z
     .object({
-    status: z.literal("agent_refreshed"),
+    status: z.literal('agent_refreshed'),
 })
     .extend(AgentStatusWithTimelineSchema.shape);
 export const RestartRequestedStatusPayloadSchema = z.object({
-    status: z.literal("restart_requested"),
+    status: z.literal('restart_requested'),
     clientId: z.string(),
     reason: z.string().optional(),
     requestId: z.string(),
 });
-export const KnownStatusPayloadSchema = z.discriminatedUnion("status", [
+export const KnownStatusPayloadSchema = z.discriminatedUnion('status', [
     AgentCreatedStatusPayloadSchema,
     AgentCreateFailedStatusPayloadSchema,
     AgentResumedStatusPayloadSchema,
@@ -1163,9 +1155,9 @@ export const KnownStatusPayloadSchema = z.discriminatedUnion("status", [
     RestartRequestedStatusPayloadSchema,
 ]);
 export const ArtifactMessageSchema = z.object({
-    type: z.literal("artifact"),
+    type: z.literal('artifact'),
     payload: z.object({
-        type: z.enum(["markdown", "diff", "image", "code"]),
+        type: z.enum(['markdown', 'diff', 'image', 'code']),
         id: z.string(),
         title: z.string(),
         content: z.string(),
@@ -1207,21 +1199,21 @@ export const ProjectPlacementPayloadSchema = z.object({
     checkout: ProjectCheckoutLitePayloadSchema,
 });
 export const AgentUpdateMessageSchema = z.object({
-    type: z.literal("agent_update"),
-    payload: z.discriminatedUnion("kind", [
+    type: z.literal('agent_update'),
+    payload: z.discriminatedUnion('kind', [
         z.object({
-            kind: z.literal("upsert"),
+            kind: z.literal('upsert'),
             agent: AgentSnapshotPayloadSchema,
             project: ProjectPlacementPayloadSchema,
         }),
         z.object({
-            kind: z.literal("remove"),
+            kind: z.literal('remove'),
             agentId: z.string(),
         }),
     ]),
 });
 export const AgentStreamMessageSchema = z.object({
-    type: z.literal("agent_stream"),
+    type: z.literal('agent_stream'),
     payload: z.object({
         agentId: z.string(),
         event: AgentStreamEventPayloadSchema,
@@ -1232,7 +1224,7 @@ export const AgentStreamMessageSchema = z.object({
     }),
 });
 export const AgentStatusMessageSchema = z.object({
-    type: z.literal("agent_status"),
+    type: z.literal('agent_status'),
     payload: z.object({
         agentId: z.string(),
         status: z.string(),
@@ -1240,15 +1232,16 @@ export const AgentStatusMessageSchema = z.object({
     }),
 });
 export const AgentListMessageSchema = z.object({
-    type: z.literal("agent_list"),
+    type: z.literal('agent_list'),
     payload: z.object({
         agents: z.array(AgentSnapshotPayloadSchema),
     }),
 });
 export const FetchAgentsResponseMessageSchema = z.object({
-    type: z.literal("fetch_agents_response"),
+    type: z.literal('fetch_agents_response'),
     payload: z.object({
         requestId: z.string(),
+        subscriptionId: z.string().nullable().optional(),
         entries: z.array(z.object({
             agent: AgentSnapshotPayloadSchema,
             project: ProjectPlacementPayloadSchema,
@@ -1261,7 +1254,7 @@ export const FetchAgentsResponseMessageSchema = z.object({
     }),
 });
 export const FetchAgentResponseMessageSchema = z.object({
-    type: z.literal("fetch_agent_response"),
+    type: z.literal('fetch_agent_response'),
     payload: z.object({
         requestId: z.string(),
         agent: AgentSnapshotPayloadSchema.nullable(),
@@ -1279,15 +1272,15 @@ export const AgentTimelineEntryPayloadSchema = z.object({
     seqStart: z.number().int().nonnegative(),
     seqEnd: z.number().int().nonnegative(),
     sourceSeqRanges: z.array(AgentTimelineSeqRangeSchema),
-    collapsed: z.array(z.enum(["assistant_merge", "tool_lifecycle"])),
+    collapsed: z.array(z.enum(['assistant_merge', 'tool_lifecycle'])),
 });
 export const FetchAgentTimelineResponseMessageSchema = z.object({
-    type: z.literal("fetch_agent_timeline_response"),
+    type: z.literal('fetch_agent_timeline_response'),
     payload: z.object({
         requestId: z.string(),
         agentId: z.string(),
-        direction: z.enum(["tail", "before", "after"]),
-        projection: z.enum(["projected", "canonical"]),
+        direction: z.enum(['tail', 'before', 'after']),
+        projection: z.enum(['projected', 'canonical']),
         epoch: z.string(),
         reset: z.boolean(),
         staleCursor: z.boolean(),
@@ -1306,7 +1299,7 @@ export const FetchAgentTimelineResponseMessageSchema = z.object({
     }),
 });
 export const SendAgentMessageResponseMessageSchema = z.object({
-    type: z.literal("send_agent_message_response"),
+    type: z.literal('send_agent_message_response'),
     payload: z.object({
         requestId: z.string(),
         agentId: z.string(),
@@ -1315,24 +1308,24 @@ export const SendAgentMessageResponseMessageSchema = z.object({
     }),
 });
 export const WaitForFinishResponseMessageSchema = z.object({
-    type: z.literal("wait_for_finish_response"),
+    type: z.literal('wait_for_finish_response'),
     payload: z.object({
         requestId: z.string(),
-        status: z.enum(["idle", "error", "permission", "timeout"]),
+        status: z.enum(['idle', 'error', 'permission', 'timeout']),
         final: AgentSnapshotPayloadSchema.nullable(),
         error: z.string().nullable(),
         lastMessage: z.string().nullable(),
     }),
 });
 export const AgentPermissionRequestMessageSchema = z.object({
-    type: z.literal("agent_permission_request"),
+    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"),
+    type: z.literal('agent_permission_resolved'),
     payload: z.object({
         agentId: z.string(),
         requestId: z.string(),
@@ -1340,14 +1333,14 @@ export const AgentPermissionResolvedMessageSchema = z.object({
     }),
 });
 export const AgentDeletedMessageSchema = z.object({
-    type: z.literal("agent_deleted"),
+    type: z.literal('agent_deleted'),
     payload: z.object({
         agentId: z.string(),
         requestId: z.string(),
     }),
 });
 export const AgentArchivedMessageSchema = z.object({
-    type: z.literal("agent_archived"),
+    type: z.literal('agent_archived'),
     payload: z.object({
         agentId: z.string(),
         archivedAt: z.string(),
@@ -1372,6 +1365,7 @@ const CheckoutStatusNotGitSchema = CheckoutStatusCommonSchema.extend({
     baseRef: z.null(),
     aheadBehind: z.null(),
     aheadOfOrigin: z.null(),
+    behindOfOrigin: z.null(),
     hasRemote: z.boolean(),
     remoteUrl: z.null(),
 });
@@ -1384,6 +1378,7 @@ const CheckoutStatusGitNonPaseoSchema = CheckoutStatusCommonSchema.extend({
     baseRef: z.string().nullable(),
     aheadBehind: AheadBehindSchema.nullable(),
     aheadOfOrigin: z.number().nullable(),
+    behindOfOrigin: z.number().nullable(),
     hasRemote: z.boolean(),
     remoteUrl: z.string().nullable(),
 });
@@ -1397,11 +1392,12 @@ const CheckoutStatusGitPaseoSchema = CheckoutStatusCommonSchema.extend({
     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"),
+    type: z.literal('checkout_status_response'),
     payload: z.union([
         CheckoutStatusNotGitSchema,
         CheckoutStatusGitNonPaseoSchema,
@@ -1415,17 +1411,17 @@ const CheckoutDiffSubscriptionPayloadSchema = z.object({
     error: CheckoutErrorSchema.nullable(),
 });
 export const SubscribeCheckoutDiffResponseSchema = z.object({
-    type: z.literal("subscribe_checkout_diff_response"),
+    type: z.literal('subscribe_checkout_diff_response'),
     payload: CheckoutDiffSubscriptionPayloadSchema.extend({
         requestId: z.string(),
     }),
 });
 export const CheckoutDiffUpdateSchema = z.object({
-    type: z.literal("checkout_diff_update"),
+    type: z.literal('checkout_diff_update'),
     payload: CheckoutDiffSubscriptionPayloadSchema,
 });
 export const CheckoutCommitResponseSchema = z.object({
-    type: z.literal("checkout_commit_response"),
+    type: z.literal('checkout_commit_response'),
     payload: z.object({
         cwd: z.string(),
         success: z.boolean(),
@@ -1434,7 +1430,7 @@ export const CheckoutCommitResponseSchema = z.object({
     }),
 });
 export const CheckoutMergeResponseSchema = z.object({
-    type: z.literal("checkout_merge_response"),
+    type: z.literal('checkout_merge_response'),
     payload: z.object({
         cwd: z.string(),
         success: z.boolean(),
@@ -1443,7 +1439,7 @@ export const CheckoutMergeResponseSchema = z.object({
     }),
 });
 export const CheckoutMergeFromBaseResponseSchema = z.object({
-    type: z.literal("checkout_merge_from_base_response"),
+    type: z.literal('checkout_merge_from_base_response'),
     payload: z.object({
         cwd: z.string(),
         success: z.boolean(),
@@ -1452,7 +1448,7 @@ export const CheckoutMergeFromBaseResponseSchema = z.object({
     }),
 });
 export const CheckoutPushResponseSchema = z.object({
-    type: z.literal("checkout_push_response"),
+    type: z.literal('checkout_push_response'),
     payload: z.object({
         cwd: z.string(),
         success: z.boolean(),
@@ -1461,7 +1457,7 @@ export const CheckoutPushResponseSchema = z.object({
     }),
 });
 export const CheckoutPrCreateResponseSchema = z.object({
-    type: z.literal("checkout_pr_create_response"),
+    type: z.literal('checkout_pr_create_response'),
     payload: z.object({
         cwd: z.string(),
         url: z.string().nullable(),
@@ -1476,9 +1472,10 @@ const CheckoutPrStatusSchema = z.object({
     state: z.string(),
     baseRefName: z.string(),
     headRefName: z.string(),
+    isMerged: z.boolean(),
 });
 export const CheckoutPrStatusResponseSchema = z.object({
-    type: z.literal("checkout_pr_status_response"),
+    type: z.literal('checkout_pr_status_response'),
     payload: z.object({
         cwd: z.string(),
         status: CheckoutPrStatusSchema.nullable(),
@@ -1488,7 +1485,7 @@ export const CheckoutPrStatusResponseSchema = z.object({
     }),
 });
 export const ValidateBranchResponseSchema = z.object({
-    type: z.literal("validate_branch_response"),
+    type: z.literal('validate_branch_response'),
     payload: z.object({
         exists: z.boolean(),
         resolvedRef: z.string().nullable(),
@@ -1498,7 +1495,7 @@ export const ValidateBranchResponseSchema = z.object({
     }),
 });
 export const BranchSuggestionsResponseSchema = z.object({
-    type: z.literal("branch_suggestions_response"),
+    type: z.literal('branch_suggestions_response'),
     payload: z.object({
         branches: z.array(z.string()),
         error: z.string().nullable(),
@@ -1506,9 +1503,16 @@ export const BranchSuggestionsResponseSchema = z.object({
     }),
 });
 export const DirectorySuggestionsResponseSchema = z.object({
-    type: z.literal("directory_suggestions_response"),
+    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(),
     }),
@@ -1519,7 +1523,7 @@ const PaseoWorktreeSchema = z.object({
     head: z.string().nullable().optional(),
 });
 export const PaseoWorktreeListResponseSchema = z.object({
-    type: z.literal("paseo_worktree_list_response"),
+    type: z.literal('paseo_worktree_list_response'),
     payload: z.object({
         worktrees: z.array(PaseoWorktreeSchema),
         error: CheckoutErrorSchema.nullable(),
@@ -1527,7 +1531,7 @@ export const PaseoWorktreeListResponseSchema = z.object({
     }),
 });
 export const PaseoWorktreeArchiveResponseSchema = z.object({
-    type: z.literal("paseo_worktree_archive_response"),
+    type: z.literal('paseo_worktree_archive_response'),
     payload: z.object({
         success: z.boolean(),
         removedAgents: z.array(z.string()).optional(),
@@ -1536,11 +1540,11 @@ export const PaseoWorktreeArchiveResponseSchema = z.object({
     }),
 });
 export const FileExplorerResponseSchema = z.object({
-    type: z.literal("file_explorer_response"),
+    type: z.literal('file_explorer_response'),
     payload: z.object({
         agentId: z.string(),
         path: z.string(),
-        mode: z.enum(["list", "file"]),
+        mode: z.enum(['list', 'file']),
         directory: FileExplorerDirectorySchema.nullable(),
         file: FileExplorerFileSchema.nullable(),
         error: z.string().nullable(),
@@ -1552,7 +1556,7 @@ const ProjectIconSchema = z.object({
     mimeType: z.string(),
 });
 export const ProjectIconResponseSchema = z.object({
-    type: z.literal("project_icon_response"),
+    type: z.literal('project_icon_response'),
     payload: z.object({
         cwd: z.string(),
         icon: ProjectIconSchema.nullable(),
@@ -1561,7 +1565,7 @@ export const ProjectIconResponseSchema = z.object({
     }),
 });
 export const FileDownloadTokenResponseSchema = z.object({
-    type: z.literal("file_download_token_response"),
+    type: z.literal('file_download_token_response'),
     payload: z.object({
         agentId: z.string(),
         path: z.string(),
@@ -1574,7 +1578,7 @@ export const FileDownloadTokenResponseSchema = z.object({
     }),
 });
 export const ListProviderModelsResponseMessageSchema = z.object({
-    type: z.literal("list_provider_models_response"),
+    type: z.literal('list_provider_models_response'),
     payload: z.object({
         provider: AgentProviderSchema,
         models: z.array(AgentModelDefinitionSchema).optional(),
@@ -1589,7 +1593,7 @@ const ProviderAvailabilitySchema = z.object({
     error: z.string().nullable().optional(),
 });
 export const ListAvailableProvidersResponseSchema = z.object({
-    type: z.literal("list_available_providers_response"),
+    type: z.literal('list_available_providers_response'),
     payload: z.object({
         providers: z.array(ProviderAvailabilitySchema),
         error: z.string().nullable().optional(),
@@ -1598,7 +1602,7 @@ export const ListAvailableProvidersResponseSchema = z.object({
     }),
 });
 export const SpeechModelsListResponseSchema = z.object({
-    type: z.literal("speech_models_list_response"),
+    type: z.literal('speech_models_list_response'),
     payload: z.object({
         modelsDir: z.string(),
         models: z.array(z.object({
@@ -1613,7 +1617,7 @@ export const SpeechModelsListResponseSchema = z.object({
     }),
 });
 export const SpeechModelsDownloadResponseSchema = z.object({
-    type: z.literal("speech_models_download_response"),
+    type: z.literal('speech_models_download_response'),
     payload: z.object({
         modelsDir: z.string(),
         downloadedModelIds: z.array(z.string()),
@@ -1627,7 +1631,7 @@ const AgentSlashCommandSchema = z.object({
     argumentHint: z.string(),
 });
 export const ListCommandsResponseSchema = z.object({
-    type: z.literal("list_commands_response"),
+    type: z.literal('list_commands_response'),
     payload: z.object({
         agentId: z.string(),
         commands: z.array(AgentSlashCommandSchema),
@@ -1635,20 +1639,6 @@ export const ListCommandsResponseSchema = z.object({
         requestId: z.string(),
     }),
 });
-const AgentCommandResultSchema = z.object({
-    text: z.string(),
-    timeline: z.array(AgentTimelineItemPayloadSchema),
-    usage: AgentUsageSchema.optional(),
-});
-export const ExecuteCommandResponseSchema = z.object({
-    type: z.literal("execute_command_response"),
-    payload: z.object({
-        agentId: z.string(),
-        result: AgentCommandResultSchema.nullable(),
-        error: z.string().nullable(),
-        requestId: z.string(),
-    }),
-});
 // ============================================================================
 // Terminal Outbound Messages
 // ============================================================================
@@ -1675,7 +1665,7 @@ const TerminalStateSchema = z.object({
     cursor: z.object({ row: z.number(), col: z.number() }),
 });
 export const ListTerminalsResponseSchema = z.object({
-    type: z.literal("list_terminals_response"),
+    type: z.literal('list_terminals_response'),
     payload: z.object({
         cwd: z.string(),
         terminals: z.array(TerminalInfoSchema.omit({ cwd: true })),
@@ -1683,14 +1673,14 @@ export const ListTerminalsResponseSchema = z.object({
     }),
 });
 export const TerminalsChangedSchema = z.object({
-    type: z.literal("terminals_changed"),
+    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"),
+    type: z.literal('create_terminal_response'),
     payload: z.object({
         terminal: TerminalInfoSchema.nullable(),
         error: z.string().nullable(),
@@ -1698,7 +1688,7 @@ export const CreateTerminalResponseSchema = z.object({
     }),
 });
 export const SubscribeTerminalResponseSchema = z.object({
-    type: z.literal("subscribe_terminal_response"),
+    type: z.literal('subscribe_terminal_response'),
     payload: z.object({
         terminalId: z.string(),
         state: TerminalStateSchema.nullable(),
@@ -1707,14 +1697,14 @@ export const SubscribeTerminalResponseSchema = z.object({
     }),
 });
 export const TerminalOutputSchema = z.object({
-    type: z.literal("terminal_output"),
+    type: z.literal('terminal_output'),
     payload: z.object({
         terminalId: z.string(),
         state: TerminalStateSchema,
     }),
 });
 export const KillTerminalResponseSchema = z.object({
-    type: z.literal("kill_terminal_response"),
+    type: z.literal('kill_terminal_response'),
     payload: z.object({
         terminalId: z.string(),
         success: z.boolean(),
@@ -1722,7 +1712,7 @@ export const KillTerminalResponseSchema = z.object({
     }),
 });
 export const AttachTerminalStreamResponseSchema = z.object({
-    type: z.literal("attach_terminal_stream_response"),
+    type: z.literal('attach_terminal_stream_response'),
     payload: z.object({
         terminalId: z.string(),
         streamId: z.number().int().nonnegative().nullable(),
@@ -1735,7 +1725,7 @@ export const AttachTerminalStreamResponseSchema = z.object({
     }),
 });
 export const DetachTerminalStreamResponseSchema = z.object({
-    type: z.literal("detach_terminal_stream_response"),
+    type: z.literal('detach_terminal_stream_response'),
     payload: z.object({
         streamId: z.number().int().nonnegative(),
         success: z.boolean(),
@@ -1743,13 +1733,13 @@ export const DetachTerminalStreamResponseSchema = z.object({
     }),
 });
 export const TerminalStreamExitSchema = z.object({
-    type: z.literal("terminal_stream_exit"),
+    type: z.literal('terminal_stream_exit'),
     payload: z.object({
         streamId: z.number().int().nonnegative(),
         terminalId: z.string(),
     }),
 });
-export const SessionOutboundMessageSchema = z.discriminatedUnion("type", [
+export const SessionOutboundMessageSchema = z.discriminatedUnion('type', [
     ActivityLogMessageSchema,
     AssistantChunkMessageSchema,
     AudioOutputMessageSchema,
@@ -1802,7 +1792,6 @@ export const SessionOutboundMessageSchema = z.discriminatedUnion("type", [
     SpeechModelsListResponseSchema,
     SpeechModelsDownloadResponseSchema,
     ListCommandsResponseSchema,
-    ExecuteCommandResponseSchema,
     ListTerminalsResponseSchema,
     TerminalsChangedSchema,
     CreateTerminalResponseSchema,
@@ -1818,31 +1807,31 @@ export const SessionOutboundMessageSchema = z.discriminatedUnion("type", [
 // ============================================================================
 // WebSocket-only messages (not session messages)
 export const WSPingMessageSchema = z.object({
-    type: z.literal("ping"),
+    type: z.literal('ping'),
 });
 export const WSPongMessageSchema = z.object({
-    type: z.literal("pong"),
+    type: z.literal('pong'),
 });
 export const WSRecordingStateMessageSchema = z.object({
-    type: z.literal("recording_state"),
+    type: z.literal('recording_state'),
     isRecording: z.boolean(),
 });
 // Wrapped session message
 export const WSSessionInboundSchema = z.object({
-    type: z.literal("session"),
+    type: z.literal('session'),
     message: SessionInboundMessageSchema,
 });
 export const WSSessionOutboundSchema = z.object({
-    type: z.literal("session"),
+    type: z.literal('session'),
     message: SessionOutboundMessageSchema,
 });
 // Complete WebSocket message schemas
-export const WSInboundMessageSchema = z.discriminatedUnion("type", [
+export const WSInboundMessageSchema = z.discriminatedUnion('type', [
     WSPingMessageSchema,
     WSRecordingStateMessageSchema,
     WSSessionInboundSchema,
 ]);
-export const WSOutboundMessageSchema = z.discriminatedUnion("type", [
+export const WSOutboundMessageSchema = z.discriminatedUnion('type', [
     WSPongMessageSchema,
     WSSessionOutboundSchema,
 ]);
@@ -1854,7 +1843,7 @@ export const WSOutboundMessageSchema = z.discriminatedUnion("type", [
  * Returns null if message should be handled at WS level only
  */
 export function extractSessionMessage(wsMsg) {
-    if (wsMsg.type === "session") {
+    if (wsMsg.type === 'session') {
         return wsMsg.message;
     }
     // Ping and recording_state are WS-level only
@@ -1865,7 +1854,7 @@ export function extractSessionMessage(wsMsg) {
  */
 export function wrapSessionMessage(sessionMsg) {
     return {
-        type: "session",
+        type: 'session',
         message: sessionMsg,
     };
 }