tuna-agent 0.1.0

package/dist/utils/claude-cli.d.ts

@@ -0,0 +1,35 @@
+export interface ClaudeCliOptions {
+    prompt: string;
+    cwd: string;
+    allowedTools?: string[];
+    disallowedTools?: string[];
+    systemPrompt?: string;
+    resumeSessionId?: string;
+    maxTurns?: number;
+    outputFormat?: 'json' | 'stream-json' | 'text';
+    onStreamLine?: (data: Record<string, unknown>) => void;
+    includePartialMessages?: boolean;
+    /** Skip MCP servers, built-in tools, and skills for faster startup */
+    lightweight?: boolean;
+    agentTeam?: boolean;
+    timeoutMs?: number;
+    signal?: AbortSignal;
+    /** Permission mode for Claude Code CLI */
+    permissionMode?: 'default' | 'plan' | 'bypassPermissions';
+    /** Callback invoked when Claude Code asks for tool approval. Return true to allow, false to deny. */
+    onPermissionRequest?: (tool: string, detail: string) => Promise<boolean>;
+    /** Local file paths to pass as input (e.g., images) via --input-file flags */
+    inputFiles?: string[];
+}
+export interface ClaudeCliResult {
+    result: string;
+    sessionId?: string;
+    costUsd?: number;
+    durationMs?: number;
+    numTurns?: number;
+    isError: boolean;
+}
+/**
+ * Spawn a Claude Code CLI session (`claude -p`) and return the result.
+ */
+export declare function runClaude(options: ClaudeCliOptions): Promise<ClaudeCliResult>;

package/dist/utils/claude-cli.js

@@ -0,0 +1,271 @@
+import { spawn, execSync } from 'child_process';
+import { StringDecoder } from 'string_decoder';
+/** Cached absolute path to `claude` binary, resolved once at first use */
+let _claudeBinPath = null;
+function getClaudeBinPath() {
+    if (_claudeBinPath)
+        return _claudeBinPath;
+    // Search common paths where claude CLI may be installed
+    const searchPaths = [
+        process.env.PATH,
+        '/opt/homebrew/bin',
+        '/usr/local/bin',
+        `${process.env.HOME}/.local/bin`,
+        `${process.env.HOME}/.npm-global/bin`,
+        '/usr/bin',
+    ].filter(Boolean).join(':');
+    try {
+        _claudeBinPath = execSync('which claude', {
+            encoding: 'utf-8',
+            env: { ...process.env, PATH: searchPaths },
+            stdio: ['ignore', 'pipe', 'ignore'],
+        }).trim();
+        console.log(`[claude-cli] Resolved claude binary: ${_claudeBinPath}`);
+        return _claudeBinPath;
+    }
+    catch {
+        // Fallback to bare 'claude' and let spawn try PATH
+        console.warn('[claude-cli] Could not resolve claude binary path, falling back to "claude"');
+        return 'claude';
+    }
+}
+// Permission prompt detection pattern:
+// Claude Code outputs tool name, detail, and a y/n prompt on stderr when in default permission mode
+const PERMISSION_PROMPT_REGEX = /(?:Allow|Approve|Permission).*?\b(Edit|Write|Bash)\b.*?([^\n]+)\n.*?\(y\/n\)/is;
+const PERMISSION_YN_REGEX = /\(y\/n\)\s*$/;
+const PERMISSION_TIMEOUT_MS = 5 * 60 * 1000; // 5 minutes
+/**
+ * Detect permission prompts from Claude Code stderr and respond via stdin.
+ */
+function handlePermissionPrompt(text, proc, onPermissionRequest) {
+    // Only process if this looks like a permission prompt (contains y/n)
+    if (!PERMISSION_YN_REGEX.test(text))
+        return;
+    // Extract tool and detail from the prompt text
+    const match = text.match(PERMISSION_PROMPT_REGEX);
+    const tool = match?.[1] ?? 'unknown';
+    const detail = match?.[2]?.trim() ?? text.trim();
+    // Set up auto-deny timeout
+    let timedOut = false;
+    const timer = setTimeout(() => {
+        timedOut = true;
+        console.warn(`[claude-cli] Permission request timed out after 5 minutes, auto-denying`);
+        proc.stdin?.write('n\n');
+    }, PERMISSION_TIMEOUT_MS);
+    onPermissionRequest(tool, detail)
+        .then((approved) => {
+        if (timedOut)
+            return;
+        clearTimeout(timer);
+        proc.stdin?.write(approved ? 'y\n' : 'n\n');
+        console.log(`[claude-cli] Permission ${approved ? 'approved' : 'denied'} for ${tool}: ${detail.substring(0, 80)}`);
+    })
+        .catch((err) => {
+        if (timedOut)
+            return;
+        clearTimeout(timer);
+        console.error(`[claude-cli] Permission callback error, auto-denying:`, err);
+        proc.stdin?.write('n\n');
+    });
+}
+/**
+ * Spawn a Claude Code CLI session (`claude -p`) and return the result.
+ */
+export function runClaude(options) {
+    return new Promise((resolve, reject) => {
+        const format = options.outputFormat ?? 'json';
+        // Append image file paths to prompt so Claude Code reads them via Read tool
+        let prompt = options.prompt;
+        if (options.inputFiles?.length) {
+            const fileList = options.inputFiles.map(f => `- ${f}`).join('\n');
+            prompt += `\n\n[User attached ${options.inputFiles.length} image(s). Read these files to see the images:]\n${fileList}`;
+        }
+        const args = ['-p', prompt, '--output-format', format];
+        if (options.allowedTools?.length) {
+            args.push('--allowedTools', options.allowedTools.join(','));
+        }
+        if (options.disallowedTools?.length) {
+            args.push('--disallowedTools', options.disallowedTools.join(','));
+        }
+        if (options.systemPrompt) {
+            args.push('--append-system-prompt', options.systemPrompt);
+        }
+        if (options.maxTurns) {
+            args.push('--max-turns', String(options.maxTurns));
+        }
+        if (options.resumeSessionId) {
+            args.push('--resume', options.resumeSessionId);
+        }
+        if (options.lightweight) {
+            args.push('--strict-mcp-config'); // skip all MCP servers
+            args.push('--tools', ''); // skip built-in tools
+            args.push('--disable-slash-commands'); // skip skills/plugins
+        }
+        if (options.permissionMode) {
+            args.push('--permission-mode', options.permissionMode);
+        }
+        if (format === 'stream-json') {
+            args.push('--verbose');
+            if (options.includePartialMessages) {
+                args.push('--include-partial-messages');
+            }
+        }
+        const useInteractiveStdin = !!options.permissionMode && !!options.onPermissionRequest;
+        const claudeBin = getClaudeBinPath();
+        // Ensure PATH includes common bin dirs so shebang `#!/usr/bin/env node` resolves
+        const spawnPath = [
+            process.env.PATH,
+            '/opt/homebrew/bin',
+            '/usr/local/bin',
+            `${process.env.HOME}/.local/bin`,
+            `${process.env.HOME}/.nvm/versions/node/v20.10.0/bin`,
+        ].filter(Boolean).join(':');
+        const proc = spawn(claudeBin, args, {
+            cwd: options.cwd,
+            stdio: [useInteractiveStdin ? 'pipe' : 'ignore', 'pipe', 'pipe'],
+            env: {
+                ...process.env,
+                HOME: process.env.HOME || '',
+                PATH: spawnPath,
+                ...(options.agentTeam ? {
+                    CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS: '1',
+                    CLAUDE_CODE_TEAMMATE_MODE: 'in-process',
+                } : {}),
+            },
+        });
+        // 30-minute timeout by default
+        const timeoutMs = options.timeoutMs ?? 30 * 60 * 1000;
+        const timeoutTimer = setTimeout(() => {
+            console.error(`[claude-cli] Process timed out after ${timeoutMs / 1000}s, killing`);
+            proc.kill('SIGTERM');
+            setTimeout(() => { if (!proc.killed)
+                proc.kill('SIGKILL'); }, 5000);
+        }, timeoutMs);
+        // Abort signal — kill process when task is cancelled
+        if (options.signal) {
+            const onAbort = () => {
+                console.log('[claude-cli] Task cancelled — killing process');
+                proc.kill('SIGTERM');
+                setTimeout(() => { if (!proc.killed)
+                    proc.kill('SIGKILL'); }, 5000);
+            };
+            if (options.signal.aborted) {
+                onAbort();
+            }
+            else {
+                options.signal.addEventListener('abort', onAbort, { once: true });
+                proc.on('close', () => options.signal.removeEventListener('abort', onAbort));
+            }
+        }
+        let stdout = '';
+        let stderr = '';
+        let buffer = '';
+        const spawnTime = Date.now();
+        let firstStdoutTime = 0;
+        let firstStreamEventTime = 0;
+        // Use StringDecoder to properly handle multi-byte UTF-8 chars split across chunks
+        const stdoutDecoder = new StringDecoder('utf8');
+        const stderrDecoder = new StringDecoder('utf8');
+        proc.stdout.on('data', (chunk) => {
+            const text = stdoutDecoder.write(chunk);
+            stdout += text;
+            if (!firstStdoutTime) {
+                firstStdoutTime = Date.now();
+                console.log(`[claude-cli] ⏱ first stdout: ${firstStdoutTime - spawnTime}ms after spawn`);
+            }
+            if (options.onStreamLine && format === 'stream-json') {
+                buffer += text;
+                const lines = buffer.split('\n');
+                buffer = lines.pop() ?? '';
+                for (const line of lines) {
+                    if (!line.trim())
+                        continue;
+                    try {
+                        const parsed = JSON.parse(line);
+                        if (!firstStreamEventTime && parsed.type === 'stream_event') {
+                            firstStreamEventTime = Date.now();
+                            const evt = parsed.event;
+                            console.log(`[claude-cli] ⏱ first stream_event (${evt?.type}): ${firstStreamEventTime - spawnTime}ms after spawn`);
+                        }
+                        options.onStreamLine(parsed);
+                    }
+                    catch {
+                        // skip non-JSON lines
+                    }
+                }
+            }
+        });
+        proc.stderr.on('data', (chunk) => {
+            const text = stderrDecoder.write(chunk);
+            stderr += text;
+            // Detect permission prompts from Claude Code on stderr
+            if (useInteractiveStdin) {
+                handlePermissionPrompt(text, proc, options.onPermissionRequest);
+            }
+        });
+        proc.on('close', (code) => {
+            clearTimeout(timeoutTimer);
+            const totalMs = Date.now() - spawnTime;
+            console.log(`[claude-cli] ⏱ process closed: ${totalMs}ms total (first stdout: ${firstStdoutTime ? firstStdoutTime - spawnTime : '?'}ms, first stream: ${firstStreamEventTime ? firstStreamEventTime - spawnTime : 'none'}ms)`);
+            // Flush remaining buffer
+            if (options.onStreamLine && buffer.trim()) {
+                try {
+                    options.onStreamLine(JSON.parse(buffer));
+                }
+                catch { /* skip */ }
+            }
+            if (code !== 0 && !stdout.trim()) {
+                const isTimeout = code === null || code === 143;
+                const errMsg = isTimeout
+                    ? `Task timed out after ${timeoutMs / 1000}s`
+                    : `claude exited with code ${code}: ${stderr}`;
+                reject(new Error(errMsg));
+                return;
+            }
+            try {
+                if (format === 'stream-json') {
+                    const lines = stdout.trim().split('\n');
+                    for (let i = lines.length - 1; i >= 0; i--) {
+                        try {
+                            const data = JSON.parse(lines[i]);
+                            if (data.type === 'result') {
+                                resolve({
+                                    result: data.result ?? '',
+                                    sessionId: data.session_id,
+                                    costUsd: data.cost_usd,
+                                    durationMs: data.duration_ms,
+                                    numTurns: data.num_turns,
+                                    isError: data.is_error ?? data.subtype !== 'success',
+                                });
+                                return;
+                            }
+                        }
+                        catch { /* skip */ }
+                    }
+                    reject(new Error('No result message found in stream output'));
+                }
+                else {
+                    const data = JSON.parse(stdout.trim());
+                    resolve({
+                        result: data.result ?? '',
+                        sessionId: data.session_id,
+                        costUsd: data.cost_usd,
+                        durationMs: data.duration_ms,
+                        numTurns: data.num_turns,
+                        isError: data.is_error ?? false,
+                    });
+                }
+            }
+            catch {
+                resolve({
+                    result: stdout.trim(),
+                    isError: code !== 0,
+                });
+            }
+        });
+        proc.on('error', (err) => {
+            clearTimeout(timeoutTimer);
+            reject(new Error(`Failed to spawn claude: ${err.message}`));
+        });
+    });
+}

package/dist/utils/execution-helpers.d.ts

@@ -0,0 +1,32 @@
+import type { AgentWebSocketClient } from '../daemon/ws-client.js';
+import type { TaskAssignment, TaskPlan, SessionInfo, ExecutionCallbacks, InputResponse } from '../types/index.js';
+/**
+ * Strip ALL markdown formatting → plain text (for session result).
+ */
+export declare function stripMarkdown(text: string): string;
+/**
+ * Simplify markdown for mobile (keep bold, italic, lists, tables - simplify code blocks).
+ */
+export declare function simplifyMarkdown(text: string): string;
+/**
+ * Convert SessionInfo to plain payload for WebSocket transmission.
+ */
+export declare function sessionToPayload(session: SessionInfo): Record<string, unknown>;
+/**
+ * Wait for user input via WebSocket. Rejects if task is cancelled.
+ */
+export declare function waitForInput(taskId: string, resolvers: Map<string, (response: InputResponse) => void>): Promise<InputResponse>;
+/**
+ * Build reusable execution callbacks for a plan.
+ * Used by both handleTask (claude-code-adapter) and resumePMChat (daemon).
+ */
+export declare function buildExecutionCallbacks(taskId: string, plan: TaskPlan, ws: AgentWebSocketClient, resolvers: Map<string, (response: InputResponse) => void>, onPermissionRequest?: (subtaskId: string, tool: string, detail: string) => Promise<boolean>): ExecutionCallbacks;
+/**
+ * Execute a plan and handle the post-execution summary.
+ * Returns the follow-up message if user wants to continue, or null if task is complete.
+ */
+export declare function executePlanAndReport(task: TaskAssignment, plan: TaskPlan, ws: AgentWebSocketClient, resolvers: Map<string, (response: InputResponse) => void>, signal?: AbortSignal, confirmBeforeEdit?: boolean, onPermissionRequest?: (subtaskId: string, tool: string, detail: string) => Promise<boolean>): Promise<{
+    sessions: SessionInfo[];
+    status: 'done' | 'failed' | 'waiting_input';
+    followUpMessage?: string;
+}>;

package/dist/utils/execution-helpers.js

@@ -0,0 +1,177 @@
+import { executeTaskWithPlan } from '../executor/task-runner.js';
+/**
+ * Strip ALL markdown formatting → plain text (for session result).
+ */
+export function stripMarkdown(text) {
+    return text
+        .replace(/\*\*(.+?)\*\*/g, '$1')
+        .replace(/\*(.+?)\*/g, '$1')
+        .replace(/`(.+?)`/g, '$1')
+        .replace(/^#+\s+/gm, '')
+        .replace(/^[-*+]\s+/gm, '')
+        .replace(/^\d+\.\s+/gm, '')
+        .replace(/\[(.+?)\]\(.+?\)/g, '$1')
+        .trim();
+}
+/**
+ * Simplify markdown for mobile (keep bold, italic, lists, tables - simplify code blocks).
+ */
+export function simplifyMarkdown(text) {
+    return text
+        .replace(/#{4,}\s+/g, '### ')
+        .trim();
+}
+/**
+ * Convert SessionInfo to plain payload for WebSocket transmission.
+ */
+export function sessionToPayload(session) {
+    return {
+        session_id: session.sessionId ?? `agent-${Date.now()}`,
+        subtask_id: session.subtaskId,
+        status: session.status,
+        result: session.result,
+        duration_ms: session.durationMs ?? 0,
+    };
+}
+/**
+ * Wait for user input via WebSocket. Rejects if task is cancelled.
+ */
+export function waitForInput(taskId, resolvers) {
+    return new Promise((resolve, reject) => {
+        resolvers.set(taskId, (response) => {
+            if (response.text === '__TASK_CANCELLED__') {
+                reject(new Error('Task cancelled'));
+            }
+            else {
+                resolve(response);
+            }
+        });
+    });
+}
+function capitalize(str) {
+    return str.charAt(0).toUpperCase() + str.slice(1);
+}
+/**
+ * Build reusable execution callbacks for a plan.
+ * Used by both handleTask (claude-code-adapter) and resumePMChat (daemon).
+ */
+export function buildExecutionCallbacks(taskId, plan, ws, resolvers, onPermissionRequest) {
+    return {
+        onSubtaskStart: async (subtaskId) => {
+            const subtask = plan.subtasks.find((s) => s.id === subtaskId);
+            if (subtask) {
+                ws.sendSubtaskStart(taskId, {
+                    id: subtask.id,
+                    role: subtask.role,
+                    description: subtask.description,
+                });
+                await new Promise(resolve => setTimeout(resolve, 100));
+                ws.sendPMMessage(taskId, {
+                    sender: 'system',
+                    content: `${capitalize(subtask.role)} session started`,
+                });
+            }
+        },
+        onSubtaskLog: async (subtaskId, logData) => {
+            ws.sendProgress(taskId, 'subtask_log', { subtaskId, log: logData });
+        },
+        onSubtaskDone: async (subtaskId, session) => {
+            const subtask = plan.subtasks.find((s) => s.id === subtaskId);
+            const roleName = subtask ? capitalize(subtask.role) : 'Session';
+            const rawResult = session.result || '';
+            const plainResult = rawResult ? stripMarkdown(rawResult) : '';
+            ws.sendSubtaskDone(taskId, {
+                subtaskId,
+                status: session.status,
+                result: plainResult,
+                durationMs: session.durationMs,
+                sessionId: session.sessionId,
+            });
+            if (session.status === 'done') {
+                const durationMs = session.durationMs;
+                const durationStr = durationMs ? `${(durationMs / 1000).toFixed(1)}s` : '';
+                const resultPreview = rawResult ? simplifyMarkdown(rawResult) : '';
+                await new Promise(resolve => setTimeout(resolve, 100));
+                ws.sendPMMessage(taskId, {
+                    sender: 'pm',
+                    content: `${roleName} completed successfully${durationStr ? ` in ${durationStr}` : ''}${resultPreview ? `\n\n${resultPreview}` : ''}`,
+                });
+            }
+            else if (session.status === 'failed') {
+                const errorMsg = rawResult ? simplifyMarkdown(rawResult).substring(0, 200) : 'Unknown error';
+                await new Promise(resolve => setTimeout(resolve, 100));
+                ws.sendPMMessage(taskId, {
+                    sender: 'pm',
+                    content: `${roleName} encountered an issue: ${errorMsg}`,
+                });
+            }
+        },
+        onSubtaskNeedsInput: async (subtaskId, question) => {
+            const subtask = plan.subtasks.find((s) => s.id === subtaskId);
+            const roleName = subtask ? capitalize(subtask.role) : 'A session';
+            ws.sendPMMessage(taskId, {
+                sender: 'pm',
+                content: `${roleName} is asking: ${question.question}`,
+                options: question.options,
+                context: question.context,
+            });
+            ws.sendNeedsInput(taskId, {
+                subtaskId,
+                question: question.question,
+                options: question.options,
+                context: question.context,
+            });
+            const { text: answer } = await waitForInput(taskId, resolvers);
+            ws.sendPMMessage(taskId, {
+                sender: 'pm',
+                content: `Got it! Passing this to ${roleName}...`,
+            });
+            return answer;
+        },
+        onLayerStart: async (layerIndex, totalLayers, subtaskIds) => {
+            ws.sendProgress(taskId, 'layer_start', { layerIndex, totalLayers, subtaskIds });
+        },
+        onPermissionRequest,
+    };
+}
+/**
+ * Execute a plan and handle the post-execution summary.
+ * Returns the follow-up message if user wants to continue, or null if task is complete.
+ */
+export async function executePlanAndReport(task, plan, ws, resolvers, signal, confirmBeforeEdit, onPermissionRequest) {
+    const callbacks = buildExecutionCallbacks(task.id, plan, ws, resolvers, onPermissionRequest);
+    const { sessions, status } = await executeTaskWithPlan(task, plan, (event, data) => { ws.sendProgress(task.id, event, data); }, callbacks, signal, confirmBeforeEdit);
+    if (status === 'waiting_input') {
+        return { sessions, status };
+    }
+    const totalDuration = sessions.reduce((sum, s) => sum + (s.durationMs ?? 0), 0);
+    const durationStr = (totalDuration / 1000).toFixed(1);
+    // Announce result
+    await new Promise(resolve => setTimeout(resolve, 150));
+    if (status === 'done') {
+        ws.sendPMMessage(task.id, {
+            sender: 'pm',
+            content: `All sessions completed in ${durationStr}s. Review the results and let me know if you need anything else.`,
+        });
+    }
+    else {
+        const failedSession = sessions.find((s) => s.status === 'failed');
+        ws.sendPMMessage(task.id, {
+            sender: 'pm',
+            content: `Some sessions had issues: ${failedSession?.result?.substring(0, 150) || 'Unknown error'}. Let me know how to proceed.`,
+        });
+    }
+    // Ask user: continue or complete?
+    ws.sendNeedsInput(task.id, {
+        subtaskId: 'follow-up',
+        question: 'Would you like to continue with anything else?',
+        options: ['Complete Task'],
+    });
+    const { text: followUpAnswer } = await waitForInput(task.id, resolvers);
+    console.log(`[Execution] Follow-up answer: ${followUpAnswer.substring(0, 80)}`);
+    if (followUpAnswer.toLowerCase() === 'complete task' || followUpAnswer.toLowerCase() === 'done') {
+        return { sessions, status };
+    }
+    // User wants to continue
+    return { sessions, status, followUpMessage: followUpAnswer };
+}

package/dist/utils/image-download.d.ts

@@ -0,0 +1,9 @@
+import type { ChatAttachment } from '../types/index.js';
+/**
+ * Download attachments to a temp directory and return local file paths.
+ */
+export declare function downloadAttachments(attachments: ChatAttachment[], taskId: string): Promise<string[]>;
+/**
+ * Clean up temp directory for a task.
+ */
+export declare function cleanupAttachments(taskId: string): void;

package/dist/utils/image-download.js

@@ -0,0 +1,60 @@
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import https from 'https';
+import http from 'http';
+/**
+ * Download attachments to a temp directory and return local file paths.
+ */
+export async function downloadAttachments(attachments, taskId) {
+    if (!attachments || attachments.length === 0)
+        return [];
+    const tmpDir = path.join(os.tmpdir(), 'tuna-attachments', taskId);
+    fs.mkdirSync(tmpDir, { recursive: true });
+    const paths = [];
+    for (const att of attachments) {
+        const safeName = `${Date.now()}_${att.file_name.replace(/[^a-zA-Z0-9._-]/g, '_')}`;
+        const localPath = path.join(tmpDir, safeName);
+        await downloadFile(att.cdn_url, localPath);
+        paths.push(localPath);
+        console.log(`[Download] ${att.file_name} → ${localPath}`);
+    }
+    return paths;
+}
+function downloadFile(url, dest) {
+    return new Promise((resolve, reject) => {
+        const mod = url.startsWith('https') ? https : http;
+        const file = fs.createWriteStream(dest);
+        mod.get(url, (response) => {
+            // Follow redirects
+            if ((response.statusCode === 301 || response.statusCode === 302) && response.headers.location) {
+                file.close();
+                fs.unlinkSync(dest);
+                downloadFile(response.headers.location, dest).then(resolve, reject);
+                return;
+            }
+            if (response.statusCode !== 200) {
+                file.close();
+                fs.unlinkSync(dest);
+                reject(new Error(`Download failed: HTTP ${response.statusCode}`));
+                return;
+            }
+            response.pipe(file);
+            file.on('finish', () => { file.close(); resolve(); });
+            file.on('error', (err) => { fs.unlinkSync(dest); reject(err); });
+        }).on('error', (err) => {
+            fs.unlinkSync(dest);
+            reject(err);
+        });
+    });
+}
+/**
+ * Clean up temp directory for a task.
+ */
+export function cleanupAttachments(taskId) {
+    const tmpDir = path.join(os.tmpdir(), 'tuna-attachments', taskId);
+    try {
+        fs.rmSync(tmpDir, { recursive: true, force: true });
+    }
+    catch { /* ignore */ }
+}

package/dist/utils/message-schemas.d.ts

@@ -0,0 +1,69 @@
+import { z } from 'zod';
+export declare const TaskAssignmentSchema: z.ZodObject<{
+    type: z.ZodLiteral<"task_assigned">;
+    task: z.ZodObject<{
+        id: z.ZodString;
+        description: z.ZodString;
+        repoPath: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+        mode: z.ZodEnum<{
+            tuna: "tuna";
+            agent_team: "agent_team";
+        }>;
+        confirmBeforeEdit: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        attachments: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            file_key: z.ZodString;
+            cdn_url: z.ZodString;
+            file_type: z.ZodString;
+            file_name: z.ZodString;
+        }, z.core.$strip>>>;
+        source: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
+            manual: "manual";
+            skill: "skill";
+            scheduled: "scheduled";
+            workflow: "workflow";
+            api: "api";
+        }>>>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const CommandMessageSchema: z.ZodObject<{
+    type: z.ZodLiteral<"command">;
+    command: z.ZodString;
+    workspace_path: z.ZodOptional<z.ZodString>;
+    skill_id: z.ZodOptional<z.ZodString>;
+    source_path: z.ZodOptional<z.ZodString>;
+    skill_name: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const TaskCancelledSchema: z.ZodObject<{
+    type: z.ZodLiteral<"task_cancelled">;
+    taskId: z.ZodString;
+}, z.core.$strip>;
+export declare const InputResponseSchema: z.ZodObject<{
+    type: z.ZodLiteral<"input_response">;
+    taskId: z.ZodString;
+    subtaskId: z.ZodOptional<z.ZodString>;
+    answer: z.ZodString;
+    attachments: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        file_key: z.ZodString;
+        cdn_url: z.ZodString;
+        file_type: z.ZodString;
+        file_name: z.ZodString;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export declare const PermissionResponseSchema: z.ZodObject<{
+    type: z.ZodLiteral<"permission_response">;
+    taskId: z.ZodOptional<z.ZodString>;
+    requestId: z.ZodString;
+    approved: z.ZodBoolean;
+}, z.core.$strip>;
+export declare const SimpleMessageSchema: z.ZodObject<{
+    type: z.ZodEnum<{
+        error: "error";
+        connected: "connected";
+        pong: "pong";
+    }>;
+}, z.core.$loose>;
+/**
+ * Validate an incoming WebSocket message and return the parsed result.
+ * Returns null if validation fails.
+ */
+export declare function validateMessage(msg: Record<string, unknown>): Record<string, unknown> | null;