byterover-cli 0.4.1 → 1.0.0

package/dist/core/domain/transport/schemas.d.ts

@@ -0,0 +1,1149 @@
+/**
+ * Transport Schemas - Types and validation for Socket.IO transport layer.
+ *
+ * Architecture (Clean Architecture compliance):
+ * - Domain types from agent-events/types.ts are the Single Source of Truth (SSOT)
+ * - Transport layer IMPORTS from domain, does NOT redefine
+ * - Transport events EXTEND domain types with `taskId` for routing
+ * - Zod schemas provide runtime validation for transport messages
+ */
+import { z } from 'zod';
+import type { AgentEventMap } from '../cipher/agent-events/types.js';
+export type { AgentTerminationReason, LogLevel, TokenUsage, ToolErrorType, UIEventType, } from '../cipher/agent-events/types.js';
+export declare const TokenUsageSchema: z.ZodObject<{
+    inputTokens: z.ZodNumber;
+    outputTokens: z.ZodNumber;
+    totalTokens: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    inputTokens: number;
+    outputTokens: number;
+    totalTokens: number;
+}, {
+    inputTokens: number;
+    outputTokens: number;
+    totalTokens: number;
+}>;
+export declare const LogLevelSchema: z.ZodEnum<["debug", "error", "info", "warn"]>;
+export declare const UIEventTypeSchema: z.ZodEnum<["banner", "help", "prompt", "response", "separator", "shutdown"]>;
+export declare const ToolErrorTypeSchema: z.ZodEnum<["CANCELLED", "CONFIRMATION_REJECTED", "EXECUTION_FAILED", "INTERNAL_ERROR", "INVALID_PARAM_TYPE", "INVALID_PARAMS", "MISSING_REQUIRED_PARAM", "PARAM_VALIDATION_FAILED", "PERMISSION_DENIED", "PROVIDER_ERROR", "TIMEOUT", "TOOL_DISABLED", "TOOL_NOT_FOUND"]>;
+export declare const AgentTerminationReasonSchema: z.ZodEnum<["ABORTED", "ERROR", "GOAL", "MAX_TURNS", "PROTOCOL_VIOLATION", "TIMEOUT"]>;
+export declare const TodoStatusSchema: z.ZodEnum<["cancelled", "completed", "in_progress", "pending"]>;
+export declare const TodoItemSchema: z.ZodObject<{
+    activeForm: z.ZodString;
+    content: z.ZodString;
+    status: z.ZodEnum<["cancelled", "completed", "in_progress", "pending"]>;
+}, "strip", z.ZodTypeAny, {
+    status: "cancelled" | "completed" | "in_progress" | "pending";
+    activeForm: string;
+    content: string;
+}, {
+    status: "cancelled" | "completed" | "in_progress" | "pending";
+    activeForm: string;
+    content: string;
+}>;
+export declare const ConversationResetPayloadSchema: z.ZodObject<{
+    sessionId: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    sessionId: string;
+}, {
+    sessionId: string;
+}>;
+export declare const ExecutionStartedPayloadSchema: z.ZodObject<{
+    maxIterations: z.ZodNumber;
+    maxTimeMs: z.ZodOptional<z.ZodNumber>;
+    sessionId: z.ZodString;
+    startTime: z.ZodDate;
+}, "strip", z.ZodTypeAny, {
+    sessionId: string;
+    maxIterations: number;
+    startTime: Date;
+    maxTimeMs?: number | undefined;
+}, {
+    sessionId: string;
+    maxIterations: number;
+    startTime: Date;
+    maxTimeMs?: number | undefined;
+}>;
+export declare const ExecutionTerminatedPayloadSchema: z.ZodObject<{
+    durationMs: z.ZodOptional<z.ZodNumber>;
+    endTime: z.ZodDate;
+    error: z.ZodOptional<z.ZodAny>;
+    reason: z.ZodEnum<["ABORTED", "ERROR", "GOAL", "MAX_TURNS", "PROTOCOL_VIOLATION", "TIMEOUT"]>;
+    sessionId: z.ZodString;
+    toolCallsExecuted: z.ZodNumber;
+    turnCount: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    sessionId: string;
+    endTime: Date;
+    reason: "TIMEOUT" | "ABORTED" | "ERROR" | "GOAL" | "MAX_TURNS" | "PROTOCOL_VIOLATION";
+    toolCallsExecuted: number;
+    turnCount: number;
+    error?: any;
+    durationMs?: number | undefined;
+}, {
+    sessionId: string;
+    endTime: Date;
+    reason: "TIMEOUT" | "ABORTED" | "ERROR" | "GOAL" | "MAX_TURNS" | "PROTOCOL_VIOLATION";
+    toolCallsExecuted: number;
+    turnCount: number;
+    error?: any;
+    durationMs?: number | undefined;
+}>;
+export declare const LogPayloadSchema: z.ZodObject<{
+    context: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    level: z.ZodEnum<["debug", "error", "info", "warn"]>;
+    message: z.ZodString;
+    sessionId: z.ZodOptional<z.ZodString>;
+    source: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    message: string;
+    level: "debug" | "error" | "info" | "warn";
+    source?: string | undefined;
+    sessionId?: string | undefined;
+    context?: Record<string, unknown> | undefined;
+}, {
+    message: string;
+    level: "debug" | "error" | "info" | "warn";
+    source?: string | undefined;
+    sessionId?: string | undefined;
+    context?: Record<string, unknown> | undefined;
+}>;
+export declare const StateChangedPayloadSchema: z.ZodObject<{
+    field: z.ZodString;
+    newValue: z.ZodUnknown;
+    oldValue: z.ZodOptional<z.ZodUnknown>;
+    sessionId: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    field: string;
+    sessionId?: string | undefined;
+    newValue?: unknown;
+    oldValue?: unknown;
+}, {
+    field: string;
+    sessionId?: string | undefined;
+    newValue?: unknown;
+    oldValue?: unknown;
+}>;
+export declare const StateResetPayloadSchema: z.ZodObject<{
+    sessionId: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    sessionId?: string | undefined;
+}, {
+    sessionId?: string | undefined;
+}>;
+export declare const UIPayloadSchema: z.ZodObject<{
+    context: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    message: z.ZodOptional<z.ZodString>;
+    sessionId: z.ZodOptional<z.ZodString>;
+    type: z.ZodEnum<["banner", "help", "prompt", "response", "separator", "shutdown"]>;
+}, "strip", z.ZodTypeAny, {
+    type: "banner" | "help" | "prompt" | "response" | "separator" | "shutdown";
+    message?: string | undefined;
+    sessionId?: string | undefined;
+    context?: Record<string, unknown> | undefined;
+}, {
+    type: "banner" | "help" | "prompt" | "response" | "separator" | "shutdown";
+    message?: string | undefined;
+    sessionId?: string | undefined;
+    context?: Record<string, unknown> | undefined;
+}>;
+export declare const ChunkPayloadSchema: z.ZodObject<{
+    content: z.ZodString;
+    isComplete: z.ZodOptional<z.ZodBoolean>;
+    sessionId: z.ZodString;
+    type: z.ZodEnum<["reasoning", "text"]>;
+}, "strip", z.ZodTypeAny, {
+    type: "reasoning" | "text";
+    content: string;
+    sessionId: string;
+    isComplete?: boolean | undefined;
+}, {
+    type: "reasoning" | "text";
+    content: string;
+    sessionId: string;
+    isComplete?: boolean | undefined;
+}>;
+export declare const ErrorPayloadSchema: z.ZodObject<{
+    code: z.ZodOptional<z.ZodString>;
+    error: z.ZodString;
+    sessionId: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    error: string;
+    sessionId: string;
+    code?: string | undefined;
+}, {
+    error: string;
+    sessionId: string;
+    code?: string | undefined;
+}>;
+export declare const OutputTruncatedPayloadSchema: z.ZodObject<{
+    originalLength: z.ZodNumber;
+    savedToFile: z.ZodString;
+    sessionId: z.ZodString;
+    toolName: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    sessionId: string;
+    originalLength: number;
+    savedToFile: string;
+    toolName: string;
+}, {
+    sessionId: string;
+    originalLength: number;
+    savedToFile: string;
+    toolName: string;
+}>;
+export declare const ResponsePayloadSchema: z.ZodObject<{
+    content: z.ZodString;
+    model: z.ZodOptional<z.ZodString>;
+    partial: z.ZodOptional<z.ZodBoolean>;
+    provider: z.ZodOptional<z.ZodString>;
+    reasoning: z.ZodOptional<z.ZodString>;
+    sessionId: z.ZodString;
+    tokenUsage: z.ZodOptional<z.ZodObject<{
+        inputTokens: z.ZodNumber;
+        outputTokens: z.ZodNumber;
+        totalTokens: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        inputTokens: number;
+        outputTokens: number;
+        totalTokens: number;
+    }, {
+        inputTokens: number;
+        outputTokens: number;
+        totalTokens: number;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    content: string;
+    sessionId: string;
+    reasoning?: string | undefined;
+    model?: string | undefined;
+    partial?: boolean | undefined;
+    provider?: string | undefined;
+    tokenUsage?: {
+        inputTokens: number;
+        outputTokens: number;
+        totalTokens: number;
+    } | undefined;
+}, {
+    content: string;
+    sessionId: string;
+    reasoning?: string | undefined;
+    model?: string | undefined;
+    partial?: boolean | undefined;
+    provider?: string | undefined;
+    tokenUsage?: {
+        inputTokens: number;
+        outputTokens: number;
+        totalTokens: number;
+    } | undefined;
+}>;
+export declare const ThinkingPayloadSchema: z.ZodObject<{
+    sessionId: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    sessionId: string;
+}, {
+    sessionId: string;
+}>;
+export declare const ThoughtPayloadSchema: z.ZodObject<{
+    description: z.ZodString;
+    sessionId: z.ZodString;
+    subject: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    sessionId: string;
+    description: string;
+    subject: string;
+}, {
+    sessionId: string;
+    description: string;
+    subject: string;
+}>;
+export declare const TodoUpdatedPayloadSchema: z.ZodObject<{
+    sessionId: z.ZodString;
+    todos: z.ZodArray<z.ZodObject<{
+        activeForm: z.ZodString;
+        content: z.ZodString;
+        status: z.ZodEnum<["cancelled", "completed", "in_progress", "pending"]>;
+    }, "strip", z.ZodTypeAny, {
+        status: "cancelled" | "completed" | "in_progress" | "pending";
+        activeForm: string;
+        content: string;
+    }, {
+        status: "cancelled" | "completed" | "in_progress" | "pending";
+        activeForm: string;
+        content: string;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    sessionId: string;
+    todos: {
+        status: "cancelled" | "completed" | "in_progress" | "pending";
+        activeForm: string;
+        content: string;
+    }[];
+}, {
+    sessionId: string;
+    todos: {
+        status: "cancelled" | "completed" | "in_progress" | "pending";
+        activeForm: string;
+        content: string;
+    }[];
+}>;
+export declare const ToolCallPayloadSchema: z.ZodObject<{
+    args: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    callId: z.ZodOptional<z.ZodString>;
+    sessionId: z.ZodString;
+    toolName: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    sessionId: string;
+    toolName: string;
+    args: Record<string, unknown>;
+    callId?: string | undefined;
+}, {
+    sessionId: string;
+    toolName: string;
+    args: Record<string, unknown>;
+    callId?: string | undefined;
+}>;
+export declare const ToolResultPayloadSchema: z.ZodObject<{
+    callId: z.ZodOptional<z.ZodString>;
+    error: z.ZodOptional<z.ZodString>;
+    errorType: z.ZodOptional<z.ZodEnum<["CANCELLED", "CONFIRMATION_REJECTED", "EXECUTION_FAILED", "INTERNAL_ERROR", "INVALID_PARAM_TYPE", "INVALID_PARAMS", "MISSING_REQUIRED_PARAM", "PARAM_VALIDATION_FAILED", "PERMISSION_DENIED", "PROVIDER_ERROR", "TIMEOUT", "TOOL_DISABLED", "TOOL_NOT_FOUND"]>>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    result: z.ZodOptional<z.ZodUnknown>;
+    sessionId: z.ZodString;
+    success: z.ZodBoolean;
+    toolName: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    sessionId: string;
+    toolName: string;
+    success: boolean;
+    error?: string | undefined;
+    callId?: string | undefined;
+    errorType?: "CANCELLED" | "CONFIRMATION_REJECTED" | "EXECUTION_FAILED" | "INTERNAL_ERROR" | "INVALID_PARAM_TYPE" | "INVALID_PARAMS" | "MISSING_REQUIRED_PARAM" | "PARAM_VALIDATION_FAILED" | "PERMISSION_DENIED" | "PROVIDER_ERROR" | "TIMEOUT" | "TOOL_DISABLED" | "TOOL_NOT_FOUND" | undefined;
+    metadata?: Record<string, unknown> | undefined;
+    result?: unknown;
+}, {
+    sessionId: string;
+    toolName: string;
+    success: boolean;
+    error?: string | undefined;
+    callId?: string | undefined;
+    errorType?: "CANCELLED" | "CONFIRMATION_REJECTED" | "EXECUTION_FAILED" | "INTERNAL_ERROR" | "INVALID_PARAM_TYPE" | "INVALID_PARAMS" | "MISSING_REQUIRED_PARAM" | "PARAM_VALIDATION_FAILED" | "PERMISSION_DENIED" | "PROVIDER_ERROR" | "TIMEOUT" | "TOOL_DISABLED" | "TOOL_NOT_FOUND" | undefined;
+    metadata?: Record<string, unknown> | undefined;
+    result?: unknown;
+}>;
+export declare const UnsupportedInputPayloadSchema: z.ZodObject<{
+    reason: z.ZodString;
+    sessionId: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    sessionId: string;
+    reason: string;
+}, {
+    sessionId: string;
+    reason: string;
+}>;
+export declare const WarningPayloadSchema: z.ZodObject<{
+    message: z.ZodString;
+    model: z.ZodOptional<z.ZodString>;
+    provider: z.ZodOptional<z.ZodString>;
+    sessionId: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    message: string;
+    sessionId: string;
+    model?: string | undefined;
+    provider?: string | undefined;
+}, {
+    message: string;
+    sessionId: string;
+    model?: string | undefined;
+    provider?: string | undefined;
+}>;
+export declare const TransportEventNames: {
+    readonly CHUNK: "llmservice:chunk";
+    readonly CONVERSATION_RESET: "cipher:conversationReset";
+    readonly ERROR: "llmservice:error";
+    readonly EXECUTION_STARTED: "cipher:executionStarted";
+    readonly EXECUTION_TERMINATED: "cipher:executionTerminated";
+    readonly LOG: "cipher:log";
+    readonly OUTPUT_TRUNCATED: "llmservice:outputTruncated";
+    readonly RESPONSE: "llmservice:response";
+    readonly STATE_CHANGED: "cipher:stateChanged";
+    readonly STATE_RESET: "cipher:stateReset";
+    readonly THINKING: "llmservice:thinking";
+    readonly THOUGHT: "llmservice:thought";
+    readonly TODO_UPDATED: "llmservice:todoUpdated";
+    readonly TOOL_CALL: "llmservice:toolCall";
+    readonly TOOL_RESULT: "llmservice:toolResult";
+    readonly UI: "cipher:ui";
+    readonly UNSUPPORTED_INPUT: "llmservice:unsupportedInput";
+    readonly WARNING: "llmservice:warning";
+};
+/**
+ * Transport Events - Sent to Clients (TUI, external CLIs)
+ *
+ * Event naming convention:
+ * - task:* events are Transport-generated (lifecycle events)
+ * - llmservice:* events are forwarded from Agent with ORIGINAL names
+ *
+ * This means FE receives the SAME event names that Agent emits internally.
+ * No mapping needed - what you see is what Agent does.
+ *
+ * Event Flow:
+ * 1. Client sends task:create → Transport generates taskId → task:ack
+ * 2. Transport forwards to Agent → Agent starts → task:started
+ * 3. Agent processes:
+ *    - LLM generates text → llmservice:response (streaming chunks)
+ *    - LLM calls a tool → llmservice:toolCall
+ *    - Tool returns result → llmservice:toolResult
+ * 4. Agent finishes → task:completed OR task:error
+ */
+export declare const TransportTaskEventNames: {
+    readonly ACK: "task:ack";
+    readonly CANCEL: "task:cancel";
+    readonly CANCELLED: "task:cancelled";
+    readonly COMPLETED: "task:completed";
+    readonly CREATE: "task:create";
+    readonly CREATED: "task:created";
+    readonly ERROR: "task:error";
+    readonly EXECUTE: "task:execute";
+    readonly STARTED: "task:started";
+};
+export declare const LlmEventNames: {
+    readonly CHUNK: "llmservice:chunk";
+    readonly ERROR: "llmservice:error";
+    readonly RESPONSE: "llmservice:response";
+    readonly THINKING: "llmservice:thinking";
+    readonly TOOL_CALL: "llmservice:toolCall";
+    readonly TOOL_RESULT: "llmservice:toolResult";
+    readonly UNSUPPORTED_INPUT: "llmservice:unsupportedInput";
+};
+/**
+ * Explicit list of LLM event names for iteration.
+ *
+ * Avoids `Object.values(LlmEventNames)` so call sites remain readable and
+ * type-safe (the list is visible and ordered intentionally).
+ */
+export declare const TransportLlmEventList: readonly ["llmservice:thinking", "llmservice:chunk", "llmservice:response", "llmservice:toolCall", "llmservice:toolResult", "llmservice:error", "llmservice:unsupportedInput"];
+/**
+ * Transport-generated Agent lifecycle/control events (internal).
+ */
+export declare const TransportAgentEventNames: {
+    readonly CONNECTED: "agent:connected";
+    readonly DISCONNECTED: "agent:disconnected";
+    readonly REGISTER: "agent:register";
+    readonly RESTART: "agent:restart";
+    readonly RESTARTED: "agent:restarted";
+    readonly RESTARTING: "agent:restarting";
+};
+/**
+ * Transport-generated session events (internal).
+ */
+export declare const TransportSessionEventNames: {
+    readonly CREATE: "session:create";
+    readonly INFO: "session:info";
+    readonly LIST: "session:list";
+    readonly SWITCH: "session:switch";
+    readonly SWITCHED: "session:switched";
+};
+/**
+ * task:execute - Transport sends task to Agent for processing
+ * Internal message, not exposed to external clients
+ */
+export declare const TaskExecuteSchema: z.ZodObject<{
+    /** Client ID that created the task (for response routing) */
+    clientId: z.ZodString;
+    /** Task content/prompt */
+    content: z.ZodString;
+    /** Optional file paths for curate --files */
+    files: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    /** Unique task identifier */
+    taskId: z.ZodString;
+    /** Task type */
+    type: z.ZodEnum<["curate", "query"]>;
+}, "strip", z.ZodTypeAny, {
+    type: "curate" | "query";
+    content: string;
+    clientId: string;
+    taskId: string;
+    files?: string[] | undefined;
+}, {
+    type: "curate" | "query";
+    content: string;
+    clientId: string;
+    taskId: string;
+    files?: string[] | undefined;
+}>;
+/**
+ * task:cancel - Transport tells Agent to cancel a task
+ */
+export declare const TaskCancelSchema: z.ZodObject<{
+    taskId: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    taskId: string;
+}, {
+    taskId: string;
+}>;
+export type TaskExecute = z.infer<typeof TaskExecuteSchema>;
+export type TaskCancel = z.infer<typeof TaskCancelSchema>;
+/**
+ * llmservice:thinking - Agent started thinking
+ * Extends: AgentEventMap['llmservice:thinking'] + taskId
+ */
+export type LlmThinkingEvent = AgentEventMap['llmservice:thinking'] & {
+    taskId: string;
+};
+/**
+ * llmservice:chunk - Streaming content chunk from Agent
+ * Extends: AgentEventMap['llmservice:chunk'] + taskId
+ */
+export type LlmChunkEvent = AgentEventMap['llmservice:chunk'] & {
+    taskId: string;
+};
+/**
+ * llmservice:error - Error from Agent LLM service
+ * Extends: AgentEventMap['llmservice:error'] + taskId
+ */
+export type LlmErrorEvent = AgentEventMap['llmservice:error'] & {
+    taskId: string;
+};
+/**
+ * llmservice:unsupportedInput - Agent received unsupported input
+ * Extends: AgentEventMap['llmservice:unsupportedInput'] + taskId
+ */
+export type LlmUnsupportedInputEvent = AgentEventMap['llmservice:unsupportedInput'] & {
+    taskId: string;
+};
+/**
+ * llmservice:response - LLM text output
+ * Extends: AgentEventMap['llmservice:response'] + taskId
+ */
+export type LlmResponseEvent = AgentEventMap['llmservice:response'] & {
+    taskId: string;
+};
+/**
+ * llmservice:toolCall - Agent invokes a tool
+ * Extends: AgentEventMap['llmservice:toolCall'] + taskId
+ */
+export type LlmToolCallEvent = AgentEventMap['llmservice:toolCall'] & {
+    taskId: string;
+};
+/**
+ * llmservice:toolResult - Tool returns result
+ * Extends: AgentEventMap['llmservice:toolResult'] + taskId
+ */
+export type LlmToolResultEvent = AgentEventMap['llmservice:toolResult'] & {
+    taskId: string;
+};
+export declare const LlmThinkingEventSchema: z.ZodObject<{
+    sessionId: z.ZodString;
+    taskId: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    sessionId: string;
+    taskId: string;
+}, {
+    sessionId: string;
+    taskId: string;
+}>;
+export declare const LlmChunkEventSchema: z.ZodObject<{
+    content: z.ZodString;
+    isComplete: z.ZodOptional<z.ZodBoolean>;
+    sessionId: z.ZodString;
+    taskId: z.ZodString;
+    type: z.ZodEnum<["reasoning", "text"]>;
+}, "strip", z.ZodTypeAny, {
+    type: "reasoning" | "text";
+    content: string;
+    sessionId: string;
+    taskId: string;
+    isComplete?: boolean | undefined;
+}, {
+    type: "reasoning" | "text";
+    content: string;
+    sessionId: string;
+    taskId: string;
+    isComplete?: boolean | undefined;
+}>;
+export declare const LlmErrorEventSchema: z.ZodObject<{
+    code: z.ZodOptional<z.ZodString>;
+    error: z.ZodString;
+    sessionId: z.ZodString;
+    taskId: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    error: string;
+    sessionId: string;
+    taskId: string;
+    code?: string | undefined;
+}, {
+    error: string;
+    sessionId: string;
+    taskId: string;
+    code?: string | undefined;
+}>;
+export declare const LlmUnsupportedInputEventSchema: z.ZodObject<{
+    reason: z.ZodString;
+    sessionId: z.ZodString;
+    taskId: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    sessionId: string;
+    reason: string;
+    taskId: string;
+}, {
+    sessionId: string;
+    reason: string;
+    taskId: string;
+}>;
+/**
+ * task:ack - Transport acknowledges task creation
+ */
+export declare const TaskAckSchema: z.ZodObject<{
+    taskId: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    taskId: string;
+}, {
+    taskId: string;
+}>;
+/**
+ * task:created - Broadcasted when a new task is created
+ * Sent to broadcast-room for TUI monitoring
+ */
+export declare const TaskCreatedSchema: z.ZodObject<{
+    /** Task content/prompt */
+    content: z.ZodString;
+    /** Optional file paths for curate --files */
+    files: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    /** Unique task identifier */
+    taskId: z.ZodString;
+    /** Task type (curate or query) */
+    type: z.ZodEnum<["curate", "query"]>;
+}, "strip", z.ZodTypeAny, {
+    type: "curate" | "query";
+    content: string;
+    taskId: string;
+    files?: string[] | undefined;
+}, {
+    type: "curate" | "query";
+    content: string;
+    taskId: string;
+    files?: string[] | undefined;
+}>;
+/**
+ * task:started - Agent begins processing the task
+ * Direct send: {taskId} only
+ * Broadcast: {taskId, content, type, files?}
+ */
+export declare const TaskStartedEventSchema: z.ZodObject<{
+    /** Task content/prompt */
+    content: z.ZodOptional<z.ZodString>;
+    /** Optional file paths for curate --files */
+    files: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    /** Unique task identifier */
+    taskId: z.ZodString;
+    /** Task type (curate or query) */
+    type: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    taskId: string;
+    type?: string | undefined;
+    content?: string | undefined;
+    files?: string[] | undefined;
+}, {
+    taskId: string;
+    type?: string | undefined;
+    content?: string | undefined;
+    files?: string[] | undefined;
+}>;
+/**
+ * task:cancelled - Task was cancelled before completion
+ * Terminal state: no more events should follow for this taskId
+ */
+export declare const TaskCancelledEventSchema: z.ZodObject<{
+    taskId: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    taskId: string;
+}, {
+    taskId: string;
+}>;
+/**
+ * task:completed - Task finished successfully
+ */
+export declare const TaskCompletedEventSchema: z.ZodObject<{
+    result: z.ZodString;
+    taskId: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    result: string;
+    taskId: string;
+}, {
+    result: string;
+    taskId: string;
+}>;
+/**
+ * Structured error object
+ * Matches TaskErrorData interface in task-error.ts
+ */
+export declare const TaskErrorDataSchema: z.ZodObject<{
+    code: z.ZodOptional<z.ZodString>;
+    details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    message: z.ZodString;
+    name: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    message: string;
+    name: string;
+    code?: string | undefined;
+    details?: Record<string, unknown> | undefined;
+}, {
+    message: string;
+    name: string;
+    code?: string | undefined;
+    details?: Record<string, unknown> | undefined;
+}>;
+/**
+ * task:error - Task failed with error
+ */
+export declare const TaskErrorEventSchema: z.ZodObject<{
+    error: z.ZodObject<{
+        code: z.ZodOptional<z.ZodString>;
+        details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        message: z.ZodString;
+        name: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        message: string;
+        name: string;
+        code?: string | undefined;
+        details?: Record<string, unknown> | undefined;
+    }, {
+        message: string;
+        name: string;
+        code?: string | undefined;
+        details?: Record<string, unknown> | undefined;
+    }>;
+    taskId: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    error: {
+        message: string;
+        name: string;
+        code?: string | undefined;
+        details?: Record<string, unknown> | undefined;
+    };
+    taskId: string;
+}, {
+    error: {
+        message: string;
+        name: string;
+        code?: string | undefined;
+        details?: Record<string, unknown> | undefined;
+    };
+    taskId: string;
+}>;
+/**
+ * llmservice:response - LLM text output
+ * Matches: AgentEventMap['llmservice:response'] + taskId
+ */
+export declare const LlmResponseEventSchema: z.ZodObject<{
+    content: z.ZodString;
+    model: z.ZodOptional<z.ZodString>;
+    partial: z.ZodOptional<z.ZodBoolean>;
+    provider: z.ZodOptional<z.ZodString>;
+    reasoning: z.ZodOptional<z.ZodString>;
+    sessionId: z.ZodString;
+    taskId: z.ZodString;
+    tokenUsage: z.ZodOptional<z.ZodObject<{
+        inputTokens: z.ZodNumber;
+        outputTokens: z.ZodNumber;
+        totalTokens: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        inputTokens: number;
+        outputTokens: number;
+        totalTokens: number;
+    }, {
+        inputTokens: number;
+        outputTokens: number;
+        totalTokens: number;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    content: string;
+    sessionId: string;
+    taskId: string;
+    reasoning?: string | undefined;
+    model?: string | undefined;
+    partial?: boolean | undefined;
+    provider?: string | undefined;
+    tokenUsage?: {
+        inputTokens: number;
+        outputTokens: number;
+        totalTokens: number;
+    } | undefined;
+}, {
+    content: string;
+    sessionId: string;
+    taskId: string;
+    reasoning?: string | undefined;
+    model?: string | undefined;
+    partial?: boolean | undefined;
+    provider?: string | undefined;
+    tokenUsage?: {
+        inputTokens: number;
+        outputTokens: number;
+        totalTokens: number;
+    } | undefined;
+}>;
+/**
+ * llmservice:toolCall - Agent invokes a tool
+ * Matches: AgentEventMap['llmservice:toolCall'] + taskId
+ */
+export declare const LlmToolCallEventSchema: z.ZodObject<{
+    args: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    callId: z.ZodOptional<z.ZodString>;
+    sessionId: z.ZodString;
+    taskId: z.ZodString;
+    toolName: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    sessionId: string;
+    toolName: string;
+    args: Record<string, unknown>;
+    taskId: string;
+    callId?: string | undefined;
+}, {
+    sessionId: string;
+    toolName: string;
+    args: Record<string, unknown>;
+    taskId: string;
+    callId?: string | undefined;
+}>;
+/**
+ * llmservice:toolResult - Tool returns result
+ * Matches: AgentEventMap['llmservice:toolResult'] + taskId
+ */
+export declare const LlmToolResultEventSchema: z.ZodObject<{
+    callId: z.ZodOptional<z.ZodString>;
+    error: z.ZodOptional<z.ZodString>;
+    errorType: z.ZodOptional<z.ZodEnum<["CANCELLED", "CONFIRMATION_REJECTED", "EXECUTION_FAILED", "INTERNAL_ERROR", "INVALID_PARAM_TYPE", "INVALID_PARAMS", "MISSING_REQUIRED_PARAM", "PARAM_VALIDATION_FAILED", "PERMISSION_DENIED", "PROVIDER_ERROR", "TIMEOUT", "TOOL_DISABLED", "TOOL_NOT_FOUND"]>>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    result: z.ZodOptional<z.ZodUnknown>;
+    sessionId: z.ZodString;
+    success: z.ZodBoolean;
+    taskId: z.ZodString;
+    toolName: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    sessionId: string;
+    toolName: string;
+    success: boolean;
+    taskId: string;
+    error?: string | undefined;
+    callId?: string | undefined;
+    errorType?: "CANCELLED" | "CONFIRMATION_REJECTED" | "EXECUTION_FAILED" | "INTERNAL_ERROR" | "INVALID_PARAM_TYPE" | "INVALID_PARAMS" | "MISSING_REQUIRED_PARAM" | "PARAM_VALIDATION_FAILED" | "PERMISSION_DENIED" | "PROVIDER_ERROR" | "TIMEOUT" | "TOOL_DISABLED" | "TOOL_NOT_FOUND" | undefined;
+    metadata?: Record<string, unknown> | undefined;
+    result?: unknown;
+}, {
+    sessionId: string;
+    toolName: string;
+    success: boolean;
+    taskId: string;
+    error?: string | undefined;
+    callId?: string | undefined;
+    errorType?: "CANCELLED" | "CONFIRMATION_REJECTED" | "EXECUTION_FAILED" | "INTERNAL_ERROR" | "INVALID_PARAM_TYPE" | "INVALID_PARAMS" | "MISSING_REQUIRED_PARAM" | "PARAM_VALIDATION_FAILED" | "PERMISSION_DENIED" | "PROVIDER_ERROR" | "TIMEOUT" | "TOOL_DISABLED" | "TOOL_NOT_FOUND" | undefined;
+    metadata?: Record<string, unknown> | undefined;
+    result?: unknown;
+}>;
+export type TaskAck = z.infer<typeof TaskAckSchema>;
+export type TaskCancelledEvent = z.infer<typeof TaskCancelledEventSchema>;
+export type TaskCreated = z.infer<typeof TaskCreatedSchema>;
+export type TaskStartedEvent = z.infer<typeof TaskStartedEventSchema>;
+export type TaskCompletedEvent = z.infer<typeof TaskCompletedEventSchema>;
+export type TaskErrorData = z.infer<typeof TaskErrorDataSchema>;
+export type TaskErrorEvent = z.infer<typeof TaskErrorEventSchema>;
+export declare const TaskTypeSchema: z.ZodEnum<["curate", "query"]>;
+/**
+ * Request to create a new task
+ */
+export declare const TaskCreateRequestSchema: z.ZodObject<{
+    /** Task content/prompt */
+    content: z.ZodString;
+    /** Optional file paths for curate --files (max 5) */
+    files: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    /** Task ID - generated by Client UseCase (UUID v4) */
+    taskId: z.ZodString;
+    /** Task type */
+    type: z.ZodEnum<["curate", "query"]>;
+}, "strip", z.ZodTypeAny, {
+    type: "curate" | "query";
+    content: string;
+    taskId: string;
+    files?: string[] | undefined;
+}, {
+    type: "curate" | "query";
+    content: string;
+    taskId: string;
+    files?: string[] | undefined;
+}>;
+/**
+ * Response after task creation
+ */
+export declare const TaskCreateResponseSchema: z.ZodObject<{
+    /** Created task ID */
+    taskId: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    taskId: string;
+}, {
+    taskId: string;
+}>;
+/**
+ * Request to cancel a task
+ */
+export declare const TaskCancelRequestSchema: z.ZodObject<{
+    taskId: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    taskId: string;
+}, {
+    taskId: string;
+}>;
+/**
+ * Response after task cancellation
+ */
+export declare const TaskCancelResponseSchema: z.ZodObject<{
+    /** Error message if cancellation failed */
+    error: z.ZodOptional<z.ZodString>;
+    success: z.ZodBoolean;
+}, "strip", z.ZodTypeAny, {
+    success: boolean;
+    error?: string | undefined;
+}, {
+    success: boolean;
+    error?: string | undefined;
+}>;
+/**
+ * Session info returned by queries
+ */
+export declare const SessionInfoSchema: z.ZodObject<{
+    createdAt: z.ZodNumber;
+    id: z.ZodString;
+    lastActiveAt: z.ZodNumber;
+    name: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    createdAt: number;
+    id: string;
+    lastActiveAt: number;
+    name?: string | undefined;
+}, {
+    createdAt: number;
+    id: string;
+    lastActiveAt: number;
+    name?: string | undefined;
+}>;
+/**
+ * Session statistics
+ */
+export declare const SessionStatsSchema: z.ZodObject<{
+    completedTasks: z.ZodNumber;
+    failedTasks: z.ZodNumber;
+    totalTasks: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    completedTasks: number;
+    failedTasks: number;
+    totalTasks: number;
+}, {
+    completedTasks: number;
+    failedTasks: number;
+    totalTasks: number;
+}>;
+/**
+ * Request for session:info (empty - get current session)
+ */
+export declare const SessionInfoRequestSchema: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+/**
+ * Response for session:info
+ */
+export declare const SessionInfoResponseSchema: z.ZodObject<{
+    session: z.ZodObject<{
+        createdAt: z.ZodNumber;
+        id: z.ZodString;
+        lastActiveAt: z.ZodNumber;
+        name: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        createdAt: number;
+        id: string;
+        lastActiveAt: number;
+        name?: string | undefined;
+    }, {
+        createdAt: number;
+        id: string;
+        lastActiveAt: number;
+        name?: string | undefined;
+    }>;
+    stats: z.ZodObject<{
+        completedTasks: z.ZodNumber;
+        failedTasks: z.ZodNumber;
+        totalTasks: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        completedTasks: number;
+        failedTasks: number;
+        totalTasks: number;
+    }, {
+        completedTasks: number;
+        failedTasks: number;
+        totalTasks: number;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    session: {
+        createdAt: number;
+        id: string;
+        lastActiveAt: number;
+        name?: string | undefined;
+    };
+    stats: {
+        completedTasks: number;
+        failedTasks: number;
+        totalTasks: number;
+    };
+}, {
+    session: {
+        createdAt: number;
+        id: string;
+        lastActiveAt: number;
+        name?: string | undefined;
+    };
+    stats: {
+        completedTasks: number;
+        failedTasks: number;
+        totalTasks: number;
+    };
+}>;
+/**
+ * Request for session:list (empty - list all)
+ */
+export declare const SessionListRequestSchema: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+/**
+ * Response for session:list
+ */
+export declare const SessionListResponseSchema: z.ZodObject<{
+    sessions: z.ZodArray<z.ZodObject<{
+        createdAt: z.ZodNumber;
+        id: z.ZodString;
+        lastActiveAt: z.ZodNumber;
+        name: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        createdAt: number;
+        id: string;
+        lastActiveAt: number;
+        name?: string | undefined;
+    }, {
+        createdAt: number;
+        id: string;
+        lastActiveAt: number;
+        name?: string | undefined;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    sessions: {
+        createdAt: number;
+        id: string;
+        lastActiveAt: number;
+        name?: string | undefined;
+    }[];
+}, {
+    sessions: {
+        createdAt: number;
+        id: string;
+        lastActiveAt: number;
+        name?: string | undefined;
+    }[];
+}>;
+/**
+ * Request for session:create
+ */
+export declare const SessionCreateRequestSchema: z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    name?: string | undefined;
+}, {
+    name?: string | undefined;
+}>;
+/**
+ * Response for session:create
+ */
+export declare const SessionCreateResponseSchema: z.ZodObject<{
+    sessionId: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    sessionId: string;
+}, {
+    sessionId: string;
+}>;
+/**
+ * Request for session:switch
+ */
+export declare const SessionSwitchRequestSchema: z.ZodObject<{
+    sessionId: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    sessionId: string;
+}, {
+    sessionId: string;
+}>;
+/**
+ * Response for session:switch
+ */
+export declare const SessionSwitchResponseSchema: z.ZodObject<{
+    success: z.ZodBoolean;
+}, "strip", z.ZodTypeAny, {
+    success: boolean;
+}, {
+    success: boolean;
+}>;
+/**
+ * Broadcast when session switches (server → all clients)
+ */
+export declare const SessionSwitchedBroadcastSchema: z.ZodObject<{
+    sessionId: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    sessionId: string;
+}, {
+    sessionId: string;
+}>;
+/**
+ * Request to restart/reinitialize the Agent.
+ * Used when config changes (e.g., after /init) require Agent to reload.
+ */
+export declare const AgentRestartRequestSchema: z.ZodObject<{
+    /** Optional reason for restart (for logging) */
+    reason: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    reason?: string | undefined;
+}, {
+    reason?: string | undefined;
+}>;
+/**
+ * Response after agent restart request.
+ */
+export declare const AgentRestartResponseSchema: z.ZodObject<{
+    /** Error message if restart failed */
+    error: z.ZodOptional<z.ZodString>;
+    /** Whether the restart was initiated successfully */
+    success: z.ZodBoolean;
+}, "strip", z.ZodTypeAny, {
+    success: boolean;
+    error?: string | undefined;
+}, {
+    success: boolean;
+    error?: string | undefined;
+}>;
+export type TodoItem = z.infer<typeof TodoItemSchema>;
+export type ChunkPayload = z.infer<typeof ChunkPayloadSchema>;
+export type ResponsePayload = z.infer<typeof ResponsePayloadSchema>;
+export type ToolCallPayload = z.infer<typeof ToolCallPayloadSchema>;
+export type ToolResultPayload = z.infer<typeof ToolResultPayloadSchema>;
+export type TodoUpdatedPayload = z.infer<typeof TodoUpdatedPayloadSchema>;
+export type ExecutionStartedPayload = z.infer<typeof ExecutionStartedPayloadSchema>;
+export type ExecutionTerminatedPayload = z.infer<typeof ExecutionTerminatedPayloadSchema>;
+export type TaskType = z.infer<typeof TaskTypeSchema>;
+export type TaskCreateRequest = z.infer<typeof TaskCreateRequestSchema>;
+export type TaskCreateResponse = z.infer<typeof TaskCreateResponseSchema>;
+export type TaskCancelRequest = z.infer<typeof TaskCancelRequestSchema>;
+export type TaskCancelResponse = z.infer<typeof TaskCancelResponseSchema>;
+export type SessionInfo = z.infer<typeof SessionInfoSchema>;
+export type SessionStats = z.infer<typeof SessionStatsSchema>;
+export type SessionInfoRequest = z.infer<typeof SessionInfoRequestSchema>;
+export type SessionInfoResponse = z.infer<typeof SessionInfoResponseSchema>;
+export type SessionListRequest = z.infer<typeof SessionListRequestSchema>;
+export type SessionListResponse = z.infer<typeof SessionListResponseSchema>;
+export type SessionCreateRequest = z.infer<typeof SessionCreateRequestSchema>;
+export type SessionCreateResponse = z.infer<typeof SessionCreateResponseSchema>;
+export type SessionSwitchRequest = z.infer<typeof SessionSwitchRequestSchema>;
+export type SessionSwitchResponse = z.infer<typeof SessionSwitchResponseSchema>;
+export type SessionSwitchedBroadcast = z.infer<typeof SessionSwitchedBroadcastSchema>;
+export type AgentRestartRequest = z.infer<typeof AgentRestartRequestSchema>;
+export type AgentRestartResponse = z.infer<typeof AgentRestartResponseSchema>;