kimaki 0.4.25 → 0.4.27

package/dist/acp-client.test.js

@@ -0,0 +1,149 @@
+// ACP client integration test for the OpenCode ACP server.
+import { afterAll, beforeAll, expect, test } from 'vitest';
+import { spawn } from 'node:child_process';
+import { Readable, Writable } from 'node:stream';
+import { ClientSideConnection, PROTOCOL_VERSION, ndJsonStream, } from '@agentclientprotocol/sdk';
+const UPDATE_TIMEOUT_MS = 5000;
+class TestClient {
+    updates = [];
+    listeners = [];
+    async requestPermission(params) {
+        const firstOption = params.options[0];
+        if (!firstOption) {
+            return { outcome: { outcome: 'cancelled' } };
+        }
+        return {
+            outcome: {
+                outcome: 'selected',
+                optionId: firstOption.optionId,
+            },
+        };
+    }
+    async sessionUpdate(params) {
+        this.updates.push(params);
+        const matching = this.listeners.filter((listener) => {
+            return listener.predicate(params);
+        });
+        this.listeners = this.listeners.filter((listener) => {
+            return !matching.includes(listener);
+        });
+        matching.forEach((listener) => {
+            clearTimeout(listener.timeout);
+            listener.resolve(params);
+        });
+    }
+    resetUpdates() {
+        this.updates = [];
+    }
+    waitForUpdate({ predicate, timeoutMs = UPDATE_TIMEOUT_MS, }) {
+        const existing = this.updates.find((update) => {
+            return predicate(update);
+        });
+        if (existing) {
+            return Promise.resolve(existing);
+        }
+        return new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => {
+                this.listeners = this.listeners.filter((listener) => {
+                    return listener.resolve !== resolve;
+                });
+                reject(new Error('Timed out waiting for session update'));
+            }, timeoutMs);
+            const listener = {
+                predicate,
+                resolve,
+                reject,
+                timeout,
+            };
+            this.listeners = [...this.listeners, listener];
+        });
+    }
+}
+let serverProcess = null;
+let connection = null;
+let client = null;
+let initResult = null;
+let sessionId = null;
+beforeAll(async () => {
+    serverProcess = spawn('opencode', ['acp', '--port', '0', '--cwd', process.cwd()], {
+        stdio: ['pipe', 'pipe', 'pipe'],
+    });
+    if (!serverProcess.stdin || !serverProcess.stdout) {
+        throw new Error('Failed to open ACP stdio streams');
+    }
+    const input = Writable.toWeb(serverProcess.stdin);
+    const output = Readable.toWeb(serverProcess.stdout);
+    const localClient = new TestClient();
+    client = localClient;
+    const stream = ndJsonStream(input, output);
+    connection = new ClientSideConnection(() => localClient, stream);
+    initResult = await connection.initialize({
+        protocolVersion: PROTOCOL_VERSION,
+        clientCapabilities: {
+            fs: {
+                readTextFile: false,
+                writeTextFile: false,
+            },
+            terminal: false,
+        },
+    });
+}, 30000);
+afterAll(async () => {
+    if (serverProcess) {
+        serverProcess.kill('SIGTERM');
+        await new Promise((resolve) => {
+            setTimeout(resolve, 500);
+        });
+        if (!serverProcess.killed) {
+            serverProcess.kill('SIGKILL');
+        }
+    }
+});
+test('creates a session and receives prompt events', async () => {
+    if (!connection || !client) {
+        throw new Error('ACP connection not initialized');
+    }
+    const sessionResponse = await connection.newSession({
+        cwd: process.cwd(),
+        mcpServers: [],
+    });
+    sessionId = sessionResponse.sessionId;
+    const promptResponse = await connection.prompt({
+        sessionId,
+        prompt: [{ type: 'text', text: 'Hello from ACP test.' }],
+    });
+    const update = await client.waitForUpdate({
+        predicate: (notification) => {
+            return (notification.sessionId === sessionId &&
+                notification.update.sessionUpdate === 'agent_message_chunk');
+        },
+    });
+    expect(promptResponse.stopReason).toBeTruthy();
+    expect(update.update.sessionUpdate).toBe('agent_message_chunk');
+}, 30000);
+test('loads an existing session and streams history', async () => {
+    if (!connection || !client) {
+        throw new Error('ACP connection not initialized');
+    }
+    if (!initResult?.agentCapabilities?.loadSession) {
+        expect(true).toBe(true);
+        return;
+    }
+    if (!sessionId) {
+        throw new Error('Missing session ID from previous test');
+    }
+    client.resetUpdates();
+    const loadPromise = connection.loadSession({
+        sessionId,
+        cwd: process.cwd(),
+        mcpServers: [],
+    });
+    const update = await client.waitForUpdate({
+        predicate: (notification) => {
+            return (notification.sessionId === sessionId &&
+                notification.update.sessionUpdate === 'user_message_chunk');
+        },
+    });
+    await loadPromise;
+    expect(update.update.sessionUpdate).toBe('user_message_chunk');
+}, 30000);

package/dist/channel-management.js

@@ -5,44 +5,46 @@ import { ChannelType, } from 'discord.js';
 import path from 'node:path';
 import { getDatabase } from './database.js';
 import { extractTagsArrays } from './xml.js';
-export async function ensureKimakiCategory(guild) {
+export async function ensureKimakiCategory(guild, botName) {
+    const categoryName = botName ? `Kimaki ${botName}` : 'Kimaki';
     const existingCategory = guild.channels.cache.find((channel) => {
         if (channel.type !== ChannelType.GuildCategory) {
             return false;
         }
-        return channel.name.toLowerCase() === 'kimaki';
+        return channel.name.toLowerCase() === categoryName.toLowerCase();
     });
     if (existingCategory) {
         return existingCategory;
     }
     return guild.channels.create({
-        name: 'Kimaki',
+        name: categoryName,
         type: ChannelType.GuildCategory,
     });
 }
-export async function ensureKimakiAudioCategory(guild) {
+export async function ensureKimakiAudioCategory(guild, botName) {
+    const categoryName = botName ? `Kimaki Audio ${botName}` : 'Kimaki Audio';
     const existingCategory = guild.channels.cache.find((channel) => {
         if (channel.type !== ChannelType.GuildCategory) {
             return false;
         }
-        return channel.name.toLowerCase() === 'kimaki audio';
+        return channel.name.toLowerCase() === categoryName.toLowerCase();
     });
     if (existingCategory) {
         return existingCategory;
     }
     return guild.channels.create({
-        name: 'Kimaki Audio',
+        name: categoryName,
         type: ChannelType.GuildCategory,
     });
 }
-export async function createProjectChannels({ guild, projectDirectory, appId, }) {
+export async function createProjectChannels({ guild, projectDirectory, appId, botName, }) {
     const baseName = path.basename(projectDirectory);
     const channelName = `${baseName}`
         .toLowerCase()
         .replace(/[^a-z0-9-]/g, '-')
         .slice(0, 100);
-    const kimakiCategory = await ensureKimakiCategory(guild);
-    const kimakiAudioCategory = await ensureKimakiAudioCategory(guild);
+    const kimakiCategory = await ensureKimakiCategory(guild, botName);
+    const kimakiAudioCategory = await ensureKimakiAudioCategory(guild, botName);
     const textChannel = await guild.channels.create({
         name: channelName,
         type: ChannelType.GuildText,

package/dist/cli.js

@@ -45,14 +45,15 @@ async function killProcessOnPort(port) {
             // Filter out our own PID and take the first (oldest)
             const targetPid = pids?.find((p) => parseInt(p, 10) !== myPid);
             if (targetPid) {
-                cliLogger.log(`Killing existing kimaki process (PID: ${targetPid})`);
-                process.kill(parseInt(targetPid, 10), 'SIGKILL');
+                const pid = parseInt(targetPid, 10);
+                cliLogger.log(`Stopping existing kimaki process (PID: ${pid})`);
+                process.kill(pid, 'SIGKILL');
                 return true;
             }
         }
     }
-    catch {
-        // Failed to kill, continue anyway
+    catch (e) {
+        cliLogger.debug(`Failed to kill process on port ${port}:`, e);
     }
     return false;
 }
@@ -69,7 +70,7 @@ async function checkSingleInstance() {
         }
     }
     catch {
-        // Connection refused means no instance running, continue
+        cliLogger.debug('No other kimaki instance detected on lock port');
     }
 }
 async function startLockServer() {
@@ -97,7 +98,9 @@ async function startLockServer() {
     });
 }
 const EXIT_NO_RESTART = 64;
-async function registerCommands(token, appId) {
+// Commands to skip when registering user commands (reserved names)
+const SKIP_USER_COMMANDS = ['init'];
+async function registerCommands(token, appId, userCommands = []) {
     const commands = [
         new SlashCommandBuilder()
             .setName('resume')
@@ -154,19 +157,11 @@ async function registerCommands(token, appId) {
         })
             .toJSON(),
         new SlashCommandBuilder()
-            .setName('accept')
-            .setDescription('Accept a pending permission request (this request only)')
-            .toJSON(),
-        new SlashCommandBuilder()
-            .setName('accept-always')
-            .setDescription('Accept and auto-approve future requests matching this pattern')
-            .toJSON(),
-        new SlashCommandBuilder()
-            .setName('reject')
-            .setDescription('Reject a pending permission request')
+            .setName('abort')
+            .setDescription('Abort the current OpenCode request in this thread')
             .toJSON(),
         new SlashCommandBuilder()
-            .setName('abort')
+            .setName('stop')
             .setDescription('Abort the current OpenCode request in this thread')
             .toJSON(),
         new SlashCommandBuilder()
@@ -181,6 +176,10 @@ async function registerCommands(token, appId) {
             .setName('model')
             .setDescription('Set the preferred model for this channel or session')
             .toJSON(),
+        new SlashCommandBuilder()
+            .setName('agent')
+            .setDescription('Set the preferred agent for this channel or session')
+            .toJSON(),
         new SlashCommandBuilder()
             .setName('queue')
             .setDescription('Queue a message to be sent after the current response finishes')
@@ -205,6 +204,25 @@ async function registerCommands(token, appId) {
             .setDescription('Redo previously undone changes')
             .toJSON(),
     ];
+    // Add user-defined commands with -cmd suffix
+    for (const cmd of userCommands) {
+        if (SKIP_USER_COMMANDS.includes(cmd.name)) {
+            continue;
+        }
+        const commandName = `${cmd.name}-cmd`;
+        const description = cmd.description || `Run /${cmd.name} command`;
+        commands.push(new SlashCommandBuilder()
+            .setName(commandName)
+            .setDescription(description.slice(0, 100)) // Discord limits to 100 chars
+            .addStringOption((option) => {
+            option
+                .setName('arguments')
+                .setDescription('Arguments to pass to the command')
+                .setRequired(false);
+            return option;
+        })
+            .toJSON());
+    }
     const rest = new REST().setToken(token);
     try {
         const data = (await rest.put(Routes.applicationCommands(appId), {
@@ -493,6 +511,7 @@ async function run({ restart, addChannels }) {
                         guild: targetGuild,
                         projectDirectory: project.worktree,
                         appId,
+                        botName: discordClient.user?.username,
                     });
                     createdChannels.push({
                         name: channelName,
@@ -510,8 +529,29 @@ async function run({ restart, addChannels }) {
             }
         }
     }
+    // Fetch user-defined commands using the already-running server
+    const allUserCommands = [];
+    try {
+        const commandsResponse = await getClient().command.list({
+            query: { directory: currentDir },
+        });
+        if (commandsResponse.data) {
+            allUserCommands.push(...commandsResponse.data);
+        }
+    }
+    catch {
+        // Ignore errors fetching commands
+    }
+    // Log available user commands
+    const registrableCommands = allUserCommands.filter((cmd) => !SKIP_USER_COMMANDS.includes(cmd.name));
+    if (registrableCommands.length > 0) {
+        const commandList = registrableCommands
+            .map((cmd) => `  /${cmd.name}-cmd - ${cmd.description || 'No description'}`)
+            .join('\n');
+        note(`Found ${registrableCommands.length} user-defined command(s):\n${commandList}`, 'OpenCode Commands');
+    }
     cliLogger.log('Registering slash commands asynchronously...');
-    void registerCommands(token, appId)
+    void registerCommands(token, appId, allUserCommands)
         .then(() => {
         cliLogger.log('Slash commands registered!');
     })

package/dist/commands/add-project.js

@@ -44,6 +44,7 @@ export async function handleAddProjectCommand({ command, appId, }) {
             guild,
             projectDirectory: directory,
             appId,
+            botName: command.client.user?.username,
         });
         await command.editReply(`✅ Created channels for project:\n📝 Text: <#${textChannelId}>\n🔊 Voice: <#${voiceChannelId}>\n📁 Directory: \`${directory}\``);
         logger.log(`Created channels for project ${channelName} at ${directory}`);

package/dist/commands/agent.js

@@ -0,0 +1,152 @@
+// /agent command - Set the preferred agent for this channel or session.
+import { ChatInputCommandInteraction, StringSelectMenuInteraction, StringSelectMenuBuilder, ActionRowBuilder, ChannelType, } from 'discord.js';
+import crypto from 'node:crypto';
+import { getDatabase, setChannelAgent, setSessionAgent, runModelMigrations } from '../database.js';
+import { initializeOpencodeForDirectory } from '../opencode.js';
+import { resolveTextChannel, getKimakiMetadata } from '../discord-utils.js';
+import { createLogger } from '../logger.js';
+const agentLogger = createLogger('AGENT');
+const pendingAgentContexts = new Map();
+export async function handleAgentCommand({ interaction, appId, }) {
+    await interaction.deferReply({ ephemeral: true });
+    runModelMigrations();
+    const channel = interaction.channel;
+    if (!channel) {
+        await interaction.editReply({ content: 'This command can only be used in a channel' });
+        return;
+    }
+    const isThread = [
+        ChannelType.PublicThread,
+        ChannelType.PrivateThread,
+        ChannelType.AnnouncementThread,
+    ].includes(channel.type);
+    let projectDirectory;
+    let channelAppId;
+    let targetChannelId;
+    let sessionId;
+    if (isThread) {
+        const thread = channel;
+        const textChannel = await resolveTextChannel(thread);
+        const metadata = getKimakiMetadata(textChannel);
+        projectDirectory = metadata.projectDirectory;
+        channelAppId = metadata.channelAppId;
+        targetChannelId = textChannel?.id || channel.id;
+        const row = getDatabase()
+            .prepare('SELECT session_id FROM thread_sessions WHERE thread_id = ?')
+            .get(thread.id);
+        sessionId = row?.session_id;
+    }
+    else if (channel.type === ChannelType.GuildText) {
+        const textChannel = channel;
+        const metadata = getKimakiMetadata(textChannel);
+        projectDirectory = metadata.projectDirectory;
+        channelAppId = metadata.channelAppId;
+        targetChannelId = channel.id;
+    }
+    else {
+        await interaction.editReply({ content: 'This command can only be used in text channels or threads' });
+        return;
+    }
+    if (channelAppId && channelAppId !== appId) {
+        await interaction.editReply({ content: 'This channel is not configured for this bot' });
+        return;
+    }
+    if (!projectDirectory) {
+        await interaction.editReply({ content: 'This channel is not configured with a project directory' });
+        return;
+    }
+    try {
+        const getClient = await initializeOpencodeForDirectory(projectDirectory);
+        const agentsResponse = await getClient().app.agents({
+            query: { directory: projectDirectory },
+        });
+        if (!agentsResponse.data || agentsResponse.data.length === 0) {
+            await interaction.editReply({ content: 'No agents available' });
+            return;
+        }
+        const agents = agentsResponse.data
+            .filter((a) => a.mode === 'primary' || a.mode === 'all')
+            .slice(0, 25);
+        if (agents.length === 0) {
+            await interaction.editReply({ content: 'No primary agents available' });
+            return;
+        }
+        const contextHash = crypto.randomBytes(8).toString('hex');
+        pendingAgentContexts.set(contextHash, {
+            dir: projectDirectory,
+            channelId: targetChannelId,
+            sessionId,
+            isThread,
+        });
+        const options = agents.map((agent) => ({
+            label: agent.name.slice(0, 100),
+            value: agent.name,
+            description: (agent.description || `${agent.mode} agent`).slice(0, 100),
+        }));
+        const selectMenu = new StringSelectMenuBuilder()
+            .setCustomId(`agent_select:${contextHash}`)
+            .setPlaceholder('Select an agent')
+            .addOptions(options);
+        const actionRow = new ActionRowBuilder().addComponents(selectMenu);
+        await interaction.editReply({
+            content: '**Set Agent Preference**\nSelect an agent:',
+            components: [actionRow],
+        });
+    }
+    catch (error) {
+        agentLogger.error('Error loading agents:', error);
+        await interaction.editReply({
+            content: `Failed to load agents: ${error instanceof Error ? error.message : 'Unknown error'}`,
+        });
+    }
+}
+export async function handleAgentSelectMenu(interaction) {
+    const customId = interaction.customId;
+    if (!customId.startsWith('agent_select:')) {
+        return;
+    }
+    await interaction.deferUpdate();
+    const contextHash = customId.replace('agent_select:', '');
+    const context = pendingAgentContexts.get(contextHash);
+    if (!context) {
+        await interaction.editReply({
+            content: 'Selection expired. Please run /agent again.',
+            components: [],
+        });
+        return;
+    }
+    const selectedAgent = interaction.values[0];
+    if (!selectedAgent) {
+        await interaction.editReply({
+            content: 'No agent selected',
+            components: [],
+        });
+        return;
+    }
+    try {
+        if (context.isThread && context.sessionId) {
+            setSessionAgent(context.sessionId, selectedAgent);
+            agentLogger.log(`Set agent ${selectedAgent} for session ${context.sessionId}`);
+            await interaction.editReply({
+                content: `Agent preference set for this session: **${selectedAgent}**`,
+                components: [],
+            });
+        }
+        else {
+            setChannelAgent(context.channelId, selectedAgent);
+            agentLogger.log(`Set agent ${selectedAgent} for channel ${context.channelId}`);
+            await interaction.editReply({
+                content: `Agent preference set for this channel: **${selectedAgent}**\n\nAll new sessions in this channel will use this agent.`,
+                components: [],
+            });
+        }
+        pendingAgentContexts.delete(contextHash);
+    }
+    catch (error) {
+        agentLogger.error('Error saving agent preference:', error);
+        await interaction.editReply({
+            content: `Failed to save agent preference: ${error instanceof Error ? error.message : 'Unknown error'}`,
+            components: [],
+        });
+    }
+}

package/dist/commands/ask-question.js

@@ -0,0 +1,184 @@
+// AskUserQuestion tool handler - Shows Discord dropdowns for AI questions.
+// When the AI uses the AskUserQuestion tool, this module renders dropdowns
+// for each question and collects user responses.
+import { StringSelectMenuBuilder, StringSelectMenuInteraction, ActionRowBuilder, } from 'discord.js';
+import crypto from 'node:crypto';
+import { sendThreadMessage, NOTIFY_MESSAGE_FLAGS } from '../discord-utils.js';
+import { getOpencodeServerPort } from '../opencode.js';
+import { createLogger } from '../logger.js';
+const logger = createLogger('ASK_QUESTION');
+// Store pending question contexts by hash
+export const pendingQuestionContexts = new Map();
+/**
+ * Show dropdown menus for question tool input.
+ * Sends one message per question with the dropdown directly under the question text.
+ */
+export async function showAskUserQuestionDropdowns({ thread, sessionId, directory, requestId, input, }) {
+    const contextHash = crypto.randomBytes(8).toString('hex');
+    const context = {
+        sessionId,
+        directory,
+        thread,
+        requestId,
+        questions: input.questions,
+        answers: {},
+        totalQuestions: input.questions.length,
+        answeredCount: 0,
+        contextHash,
+    };
+    pendingQuestionContexts.set(contextHash, context);
+    // Send one message per question with its dropdown directly underneath
+    for (let i = 0; i < input.questions.length; i++) {
+        const q = input.questions[i];
+        // Map options to Discord select menu options
+        // Discord max: 25 options per select menu
+        const options = [
+            ...q.options.slice(0, 24).map((opt, optIdx) => ({
+                label: opt.label.slice(0, 100),
+                value: `${optIdx}`,
+                description: opt.description.slice(0, 100),
+            })),
+            {
+                label: 'Other',
+                value: 'other',
+                description: 'Provide a custom answer in chat',
+            },
+        ];
+        const selectMenu = new StringSelectMenuBuilder()
+            .setCustomId(`ask_question:${contextHash}:${i}`)
+            .setPlaceholder(`Select an option`)
+            .addOptions(options);
+        // Enable multi-select if the question supports it
+        if (q.multiple) {
+            selectMenu.setMinValues(1);
+            selectMenu.setMaxValues(options.length);
+        }
+        const actionRow = new ActionRowBuilder().addComponents(selectMenu);
+        await thread.send({
+            content: `**${q.header}**\n${q.question}`,
+            components: [actionRow],
+            flags: NOTIFY_MESSAGE_FLAGS,
+        });
+    }
+    logger.log(`Showed ${input.questions.length} question dropdown(s) for session ${sessionId}`);
+}
+/**
+ * Handle dropdown selection for AskUserQuestion.
+ */
+export async function handleAskQuestionSelectMenu(interaction) {
+    const customId = interaction.customId;
+    if (!customId.startsWith('ask_question:')) {
+        return;
+    }
+    const parts = customId.split(':');
+    const contextHash = parts[1];
+    const questionIndex = parseInt(parts[2], 10);
+    if (!contextHash) {
+        await interaction.reply({
+            content: 'Invalid selection.',
+            ephemeral: true,
+        });
+        return;
+    }
+    const context = pendingQuestionContexts.get(contextHash);
+    if (!context) {
+        await interaction.reply({
+            content: 'This question has expired. Please ask the AI again.',
+            ephemeral: true,
+        });
+        return;
+    }
+    await interaction.deferUpdate();
+    const selectedValues = interaction.values;
+    const question = context.questions[questionIndex];
+    if (!question) {
+        logger.error(`Question index ${questionIndex} not found in context`);
+        return;
+    }
+    // Check if "other" was selected
+    if (selectedValues.includes('other')) {
+        // User wants to provide custom answer
+        // For now, mark as "Other" - they can type in chat
+        context.answers[questionIndex] = ['Other (please type your answer in chat)'];
+    }
+    else {
+        // Map value indices back to option labels
+        context.answers[questionIndex] = selectedValues.map((v) => {
+            const optIdx = parseInt(v, 10);
+            return question.options[optIdx]?.label || `Option ${optIdx + 1}`;
+        });
+    }
+    context.answeredCount++;
+    // Update this question's message: show answer and remove dropdown
+    const answeredText = context.answers[questionIndex].join(', ');
+    await interaction.editReply({
+        content: `**${question.header}**\n${question.question}\n✓ _${answeredText}_`,
+        components: [], // Remove the dropdown
+    });
+    // Check if all questions are answered
+    if (context.answeredCount >= context.totalQuestions) {
+        // All questions answered - send result back to session
+        await submitQuestionAnswers(context);
+        pendingQuestionContexts.delete(contextHash);
+    }
+}
+/**
+ * Submit all collected answers back to the OpenCode session.
+ * Uses the question.reply API to provide answers to the waiting tool.
+ */
+async function submitQuestionAnswers(context) {
+    try {
+        // Build answers array: each element is an array of selected labels for that question
+        const answersPayload = context.questions.map((_, i) => {
+            return context.answers[i] || [];
+        });
+        // Reply to the question using direct HTTP call to OpenCode API
+        // (v1 SDK doesn't have question.reply, so we call it directly)
+        const port = getOpencodeServerPort(context.directory);
+        if (!port) {
+            throw new Error('OpenCode server not found for directory');
+        }
+        const response = await fetch(`http://127.0.0.1:${port}/question/${context.requestId}/reply`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ answers: answersPayload }),
+        });
+        if (!response.ok) {
+            const text = await response.text();
+            throw new Error(`Failed to reply to question: ${response.status} ${text}`);
+        }
+        logger.log(`Submitted answers for question ${context.requestId} in session ${context.sessionId}`);
+    }
+    catch (error) {
+        logger.error('Failed to submit answers:', error);
+        await sendThreadMessage(context.thread, `✗ Failed to submit answers: ${error instanceof Error ? error.message : 'Unknown error'}`);
+    }
+}
+/**
+ * Check if a tool part is an AskUserQuestion tool.
+ * Returns the parsed input if valid, null otherwise.
+ */
+export function parseAskUserQuestionTool(part) {
+    if (part.type !== 'tool') {
+        return null;
+    }
+    // Check for the tool name (case-insensitive)
+    const toolName = part.tool?.toLowerCase();
+    if (toolName !== 'question') {
+        return null;
+    }
+    const input = part.state?.input;
+    if (!input?.questions || !Array.isArray(input.questions) || input.questions.length === 0) {
+        return null;
+    }
+    // Validate structure
+    for (const q of input.questions) {
+        if (typeof q.question !== 'string' ||
+            typeof q.header !== 'string' ||
+            !Array.isArray(q.options) ||
+            q.options.length < 2) {
+            return null;
+        }
+    }
+    return input;
+}