@myrialabs/clopen 0.0.7 → 0.1.1

package/backend/index.ts

@@ -1,4 +1,13 @@
 #!/usr/bin/env bun
+
+// Runtime guard — Bun only, reject Node.js and Deno
+if (typeof globalThis.Bun === 'undefined') {
+	console.error('\x1b[31mError: Clopen requires Bun runtime.\x1b[0m');
+	console.error('Node.js and Deno are not supported.');
+	console.error('Install Bun: https://bun.sh');
+	process.exit(1);
+}
+
 // MUST be first import — cleans process.env before any other module reads it
 import { SERVER_ENV } from './lib/shared/env';
 
@@ -14,6 +23,7 @@ import { debug } from '$shared/utils/logger';
 import { findAvailablePort } from './lib/shared/port-utils';
 import { networkInterfaces } from 'os';
 import { resolve } from 'node:path';
+import { statSync } from 'node:fs';
 
 // Import WebSocket router
 import { wsRouter } from './ws';
@@ -57,19 +67,27 @@ const app = new Elysia()
 	.use(wsRouter.asPlugin('/ws'));
 
 if (!isDevelopment) {
-	// Production: serve static files from dist/ using @elysiajs/static
-	const { staticPlugin } = await import('@elysiajs/static');
-
-	app.use(staticPlugin({
-		assets: 'dist',
-		prefix: '/',
-	}));
-
-	// SPA fallback: serve index.html for any unmatched route (client-side routing)
+	// Production: serve static files manually instead of @elysiajs/static.
+	// The static plugin tries to serve directories (like /) as files via Bun.file(),
+	// which hangs on some devices/platforms. Using statSync to verify the path is
+	// an actual file before serving avoids this issue.
 	const distDir = resolve(process.cwd(), 'dist');
 	const indexHtml = await Bun.file(resolve(distDir, 'index.html')).text();
 
-	app.get('/*', () => {
+	app.all('/*', ({ path }) => {
+		// Serve static files from dist/
+		if (path !== '/' && !path.includes('..')) {
+			const filePath = resolve(distDir, path.slice(1));
+			if (filePath.startsWith(distDir)) {
+				try {
+					if (statSync(filePath).isFile()) {
+						return new Response(Bun.file(filePath));
+					}
+				} catch {}
+			}
+		}
+
+		// SPA fallback: serve cached index.html
 		return new Response(indexHtml, {
 			headers: { 'Content-Type': 'text/html; charset=utf-8' }
 		});

package/backend/lib/chat/stream-manager.ts

@@ -438,33 +438,121 @@ class StreamManager extends EventEmitter {
 					continue;
 				}
 
-				// Handle compact boundary messages
+				// Handle compact boundary messages — save to DB and show in chat UI
 				if (message.type === 'system' && message.subtype === 'compact_boundary') {
 					const compactMessage = message as SDKCompactBoundaryMessage;
 					streamState.hasCompactBoundary = true;
+					const compactTimestamp = new Date().toISOString();
+
+					// Save to DB so compact boundary persists across refresh
+					let savedCompactId: string | undefined;
+					let savedCompactParentId: string | null = null;
+					if (chatSessionId) {
+						const saved = await this.saveMessage(
+							message,
+							chatSessionId,
+							compactTimestamp,
+							requestData.senderId,
+							requestData.senderName
+						);
+						savedCompactId = saved?.id;
+						savedCompactParentId = saved?.parent_message_id || null;
+					}
 
 					streamState.messages.push({
 						processId: streamState.processId,
 						message,
-						timestamp: new Date().toISOString(),
+						timestamp: compactTimestamp,
+						message_id: savedCompactId,
+						parent_message_id: savedCompactParentId,
 						compactBoundary: {
 							trigger: compactMessage.compact_metadata.trigger,
 							preTokens: compactMessage.compact_metadata.pre_tokens
 						}
 					});
 
-					this.emitStreamEvent(streamState, 'notification', {
-						notification: {
-							type: 'info',
-							title: 'Conversation Compacted',
-							message: `Conversation history has been compacted (${compactMessage.compact_metadata.trigger} trigger).`,
-							icon: 'lucide:layers'
-						},
-						timestamp: new Date().toISOString()
+					// Emit as chat:message so it shows in the chat UI
+					this.emitStreamEvent(streamState, 'message', {
+						processId: streamState.processId,
+						message,
+						timestamp: compactTimestamp,
+						message_id: savedCompactId,
+						parent_message_id: savedCompactParentId,
+						sender_id: requestData.senderId,
+						sender_name: requestData.senderName
 					});
+
+					continue;
+				}
+
+				// ──────────────────────────────────────────────────────────────
+				// Filter non-conversation SDK message types
+				// These are transient/metadata events that should NOT be saved
+				// to the database. Some are converted to notifications.
+				// ──────────────────────────────────────────────────────────────
+
+				// Handle rate_limit_event — convert to notification, don't save
+				if (message.type === 'rate_limit_event') {
+					const rateLimitMsg = message as any;
+					const info = rateLimitMsg.rate_limit_info;
+					if (info?.status === 'rejected' || info?.status === 'allowed_warning') {
+						const isRejected = info.status === 'rejected';
+						const resetTime = info.resetsAt
+							? new Date(info.resetsAt * 1000).toLocaleTimeString()
+							: 'unknown';
+						this.emitStreamEvent(streamState, 'notification', {
+							notification: {
+								type: isRejected ? 'error' : 'warning',
+								title: isRejected ? 'Rate Limit Reached' : 'Rate Limit Warning',
+								message: isRejected
+									? `Rate limit exceeded. Resets at ${resetTime}.`
+									: `Approaching rate limit (${Math.round((info.utilization || 0) * 100)}% used). Resets at ${resetTime}.`,
+								icon: isRejected ? 'lucide:ban' : 'lucide:alert-triangle'
+							},
+							timestamp: new Date().toISOString()
+						});
+					}
 					continue;
 				}
 
+				// Handle result messages — extract useful info, don't save to DB
+				if (message.type === 'result') {
+					const resultMsg = message as any;
+					if (resultMsg.subtype !== 'success' && resultMsg.errors?.length) {
+						debug.warn('chat', `SDK result error: ${resultMsg.subtype}`, resultMsg.errors);
+					}
+					continue;
+				}
+
+				// Skip all other system subtypes that aren't conversation content
+				// (init and compact_boundary are already handled above)
+				if (message.type === 'system') {
+					const subtype = (message as any).subtype;
+					// Compact boundary is handled above — this catches remaining subtypes:
+					// status, hook_started, hook_progress, hook_response,
+					// task_notification, task_started, task_progress,
+					// files_persisted, elicitation_complete, local_command_output
+					if (subtype !== 'compact_boundary') {
+						debug.log('chat', `[SM] Skipping system message subtype: ${subtype}`);
+						continue;
+					}
+				}
+
+				// Skip transient metadata events (not conversation content)
+				if (
+					message.type === 'tool_progress' ||
+					message.type === 'auth_status' ||
+					message.type === 'tool_use_summary' ||
+					message.type === 'prompt_suggestion'
+				) {
+					debug.log('chat', `[SM] Skipping transient message type: ${message.type}`);
+					continue;
+				}
+
+				// ──────────────────────────────────────────────────────────────
+				// Handle partial messages (streaming events)
+				// ──────────────────────────────────────────────────────────────
+
 				// Handle partial messages (streaming events)
 				if (message.type === 'stream_event') {
 					const partialMessage = message as SDKPartialAssistantMessage;
@@ -837,6 +925,38 @@ class StreamManager extends EventEmitter {
 	/**
 	 * Cancel an active stream
 	 */
+	/**
+	 * Resolve a pending AskUserQuestion for an active stream.
+	 * Unblocks the engine's canUseTool callback so the SDK can continue.
+	 */
+	resolveUserAnswer(chatSessionId: string, projectId: string | undefined, toolUseId: string, answers: Record<string, string>): boolean {
+		// Find the active stream for this session
+		const sessionKey = this.getSessionKey(projectId, chatSessionId);
+		const streamId = this.sessionStreams.get(sessionKey);
+		if (!streamId) {
+			debug.warn('chat', 'resolveUserAnswer: No stream found for session');
+			return false;
+		}
+
+		const streamState = this.activeStreams.get(streamId);
+		if (!streamState || streamState.status !== 'active') {
+			debug.warn('chat', 'resolveUserAnswer: Stream not active');
+			return false;
+		}
+
+		// Get the engine for this project
+		const pid = streamState.projectId || 'default';
+		const engine = getProjectEngine(pid, streamState.engine);
+
+		if (!engine.resolveUserAnswer) {
+			debug.warn('chat', 'resolveUserAnswer: Engine does not support resolveUserAnswer');
+			return false;
+		}
+
+		debug.log('chat', 'Resolving AskUserQuestion answer:', { toolUseId, answers });
+		return engine.resolveUserAnswer(toolUseId, answers);
+	}
+
 	async cancelStream(streamId: string): Promise<boolean> {
 		const streamState = this.activeStreams.get(streamId);
 		if (!streamState || streamState.status !== 'active') {

package/backend/lib/database/queries/message-queries.ts

@@ -437,6 +437,53 @@ export const messageQueries = {
 		return candidateRoot;
 	},
 
+	/**
+	 * Mark messages with unanswered tool_use blocks as interrupted.
+	 * Called when stream ends (complete/error/cancel) to persist the interrupted state.
+	 * Adds metadata.interrupted = true to the sdk_message JSON at the message level.
+	 */
+	markInterruptedMessages(sessionId: string): void {
+		const db = getDatabase();
+
+		// Get all visible messages for the session
+		const messages = db.prepare(`
+			SELECT id, sdk_message FROM messages
+			WHERE session_id = ? AND (is_deleted IS NULL OR is_deleted = 0)
+			ORDER BY timestamp ASC
+		`).all(sessionId) as { id: string; sdk_message: string }[];
+
+		// Collect all tool_use_ids that have a matching tool_result
+		const answeredToolIds = new Set<string>();
+		for (const msg of messages) {
+			const sdk = JSON.parse(msg.sdk_message);
+			if (sdk.type !== 'user' || !sdk.message?.content) continue;
+			const content = Array.isArray(sdk.message.content) ? sdk.message.content : [];
+			for (const item of content) {
+				if (item.type === 'tool_result' && item.tool_use_id) {
+					answeredToolIds.add(item.tool_use_id);
+				}
+			}
+		}
+
+		// Find assistant messages with unanswered tool_use blocks and mark them
+		const updateStmt = db.prepare(`UPDATE messages SET sdk_message = ? WHERE id = ?`);
+
+		for (const msg of messages) {
+			const sdk = JSON.parse(msg.sdk_message);
+			if (sdk.type !== 'assistant' || !sdk.message?.content) continue;
+			const content = Array.isArray(sdk.message.content) ? sdk.message.content : [];
+
+			const hasUnansweredTool = content.some(
+				(item: any) => item.type === 'tool_use' && item.id && !answeredToolIds.has(item.id)
+			);
+
+			if (hasUnansweredTool && !sdk.metadata?.interrupted) {
+				sdk.metadata = { ...sdk.metadata, interrupted: true };
+				updateStmt.run(JSON.stringify(sdk), msg.id);
+			}
+		}
+	},
+
 	/**
 	 * Group orphaned messages by their branch root
 	 * Returns map of branchRootId -> [orphaned messages]

package/backend/lib/engine/adapters/claude/stream.ts

@@ -7,7 +7,7 @@
 
 
 import { query, type SDKMessage, type EngineSDKMessage, type Options, type Query, type SDKUserMessage } from '$shared/types/messaging';
-import type { PermissionMode } from "@anthropic-ai/claude-agent-sdk";
+import type { PermissionMode, PermissionResult } from "@anthropic-ai/claude-agent-sdk";
 import { normalizePath } from './path-utils';
 import { setupEnvironmentOnce, getEngineEnv } from './environment';
 import { handleStreamError } from './error-handler';
@@ -18,6 +18,12 @@ import { CLAUDE_CODE_MODELS } from '$shared/constants/engines';
 
 import { debug } from '$shared/utils/logger';
 
+/** Pending AskUserQuestion resolver — stored while SDK is blocked waiting for user input */
+interface PendingUserAnswer {
+  resolve: (result: PermissionResult) => void;
+  input: Record<string, unknown>;
+}
+
 /** Type guard for AsyncIterable */
 function isAsyncIterable<T>(value: unknown): value is AsyncIterable<T> {
   return value != null && typeof value === 'object' && Symbol.asyncIterator in value;
@@ -28,6 +34,7 @@ export class ClaudeCodeEngine implements AIEngine {
   private _isInitialized = false;
   private activeController: AbortController | null = null;
   private activeQuery: Query | null = null;
+  private pendingUserAnswers = new Map<string, PendingUserAnswer>();
 
   get isInitialized(): boolean {
     return this._isInitialized;
@@ -49,6 +56,7 @@ export class ClaudeCodeEngine implements AIEngine {
 
   async dispose(): Promise<void> {
     await this.cancel();
+    this.pendingUserAnswers.clear();
     this._isInitialized = false;
   }
 
@@ -99,6 +107,35 @@ export class ClaudeCodeEngine implements AIEngine {
         systemPrompt: { type: "preset", preset: "claude_code" },
         settingSources: ["user", "project", "local"],
         forkSession: true,
+        // Custom permission handler: blocks on AskUserQuestion until user answers,
+        // auto-allows everything else. Works alongside bypassPermissions.
+        canUseTool: async (_toolName, input, options) => {
+          if (_toolName === 'AskUserQuestion') {
+            debug.log('engine', `AskUserQuestion detected (toolUseID: ${options.toolUseID}), waiting for user input...`);
+            return new Promise<PermissionResult>((resolve) => {
+              // Handle abort (stream cancelled while waiting)
+              if (options.signal.aborted) {
+                resolve({ behavior: 'deny', message: 'Cancelled' });
+                return;
+              }
+              const onAbort = () => {
+                this.pendingUserAnswers.delete(options.toolUseID);
+                resolve({ behavior: 'deny', message: 'Cancelled' });
+              };
+              options.signal.addEventListener('abort', onAbort, { once: true });
+
+              this.pendingUserAnswers.set(options.toolUseID, {
+                resolve: (result: PermissionResult) => {
+                  options.signal.removeEventListener('abort', onAbort);
+                  resolve(result);
+                },
+                input
+              });
+            });
+          }
+          // Auto-allow all other tools
+          return { behavior: 'allow' as const, updatedInput: input };
+        },
         ...(model && { model }),
         ...(resume && { resume }),
         ...(maxTurns && { maxTurns }),
@@ -155,6 +192,8 @@ export class ClaudeCodeEngine implements AIEngine {
       this.activeController = null;
     }
     this.activeQuery = null;
+    // Reject all pending user answer promises (abort signal handles this, but clean up the map)
+    this.pendingUserAnswers.clear();
   }
 
   /**
@@ -174,4 +213,29 @@ export class ClaudeCodeEngine implements AIEngine {
       await this.activeQuery.setPermissionMode(mode);
     }
   }
+
+  /**
+   * Resolve a pending AskUserQuestion by providing the user's answers.
+   * This unblocks the canUseTool callback, allowing the SDK to continue.
+   */
+  resolveUserAnswer(toolUseId: string, answers: Record<string, string>): boolean {
+    const pending = this.pendingUserAnswers.get(toolUseId);
+    if (!pending) {
+      debug.warn('engine', 'resolveUserAnswer: No pending question for toolUseId:', toolUseId);
+      return false;
+    }
+
+    debug.log('engine', `Resolving AskUserQuestion (toolUseID: ${toolUseId})`);
+
+    pending.resolve({
+      behavior: 'allow',
+      updatedInput: {
+        ...pending.input,
+        answers
+      }
+    });
+
+    this.pendingUserAnswers.delete(toolUseId);
+    return true;
+  }
 }

package/backend/lib/engine/adapters/opencode/message-converter.ts

@@ -22,14 +22,10 @@ import type {
 	GrepInput,
 	WebFetchInput,
 	WebSearchInput,
-	AgentInput,
-	NotebookEditInput,
-	KillShellInput,
+	AskUserQuestionInput,
 	ListMcpResourcesInput,
 	ReadMcpResourceInput,
-	TaskOutputInput,
 	TodoWriteInput,
-	ExitPlanModeInput,
 } from '@anthropic-ai/claude-agent-sdk/sdk-tools';
 
 // ============================================================
@@ -67,13 +63,17 @@ export function getToolInput(toolPart: ToolPart): OCToolInput {
 	return input;
 }
 
-/** All Claude Code tool input types */
-type ClaudeToolInput =
+/**
+ * Normalized tool input types.
+ * Only includes tools that exist in OpenCode SDK:
+ * bash, read, edit, write, glob, grep, webfetch, websearch,
+ * question, todowrite, todoread, patch, list, skill, lsp
+ */
+type NormalizedToolInput =
 	| BashInput | FileReadInput | FileEditInput | FileWriteInput
 	| GlobInput | GrepInput | WebFetchInput | WebSearchInput
-	| AgentInput | NotebookEditInput | KillShellInput
-	| ListMcpResourcesInput | ReadMcpResourceInput
-	| TaskOutputInput | TodoWriteInput | ExitPlanModeInput;
+	| AskUserQuestionInput | TodoWriteInput
+	| ListMcpResourcesInput | ReadMcpResourceInput;
 
 /** Text content block */
 interface TextContentBlock {
@@ -86,7 +86,7 @@ interface ToolUseContentBlock {
 	type: 'tool_use';
 	id: string;
 	name: string;
-	input: ClaudeToolInput;
+	input: NormalizedToolInput;
 	$result?: ToolResult;
 }
 
@@ -97,34 +97,42 @@ type ContentBlock = TextContentBlock | ToolUseContentBlock;
 // ============================================================
 
 /**
- * OpenCode tool names → Claude Code tool names
+ * OpenCode tool names → Claude Code tool names (for UI rendering)
+ *
+ * Only maps tools that exist in OpenCode SDK:
+ * bash, read, edit, write, glob, grep, webfetch, websearch,
+ * question, todowrite, todoread, patch, list, skill, lsp
  *
- * OpenCode tool names (from Go source):
- *   bash, view, edit, write, glob, grep, fetch, ls, patch, diagnostics, sourcegraph
+ * @see https://opencode.ai/docs/tools
  */
 const TOOL_NAME_MAP: Record<string, string> = {
+	// File operations
 	'bash': 'Bash',
 	'view': 'Read',
 	'read': 'Read',
 	'write': 'Write',
 	'edit': 'Edit',
+	'patch': 'Patch',
+	// Search & discovery
 	'glob': 'Glob',
 	'grep': 'Grep',
+	'list': 'List',
+	// Web
 	'fetch': 'WebFetch',
 	'web_fetch': 'WebFetch',
 	'webfetch': 'WebFetch',
 	'web_search': 'WebSearch',
 	'websearch': 'WebSearch',
-	'task': 'Task',
+	// Task management
 	'todo_write': 'TodoWrite',
 	'todowrite': 'TodoWrite',
 	'todoread': 'TodoWrite',
-	'notebook_edit': 'NotebookEdit',
-	'notebookedit': 'NotebookEdit',
-	'exit_plan_mode': 'ExitPlanMode',
-	'exitplanmode': 'ExitPlanMode',
-	'kill_shell': 'KillShell',
-	'killshell': 'KillShell',
+	// User interaction
+	'question': 'AskUserQuestion',
+	// Code intelligence & utilities
+	'skill': 'Skill',
+	'lsp': 'Lsp',
+	// MCP (custom servers)
 	'list_mcp_resources': 'ListMcpResources',
 	'read_mcp_resource': 'ReadMcpResource',
 };
@@ -282,40 +290,9 @@ function normalizeWebSearchInput(raw: OCToolInput): WebSearchInput {
 	return result;
 }
 
-function normalizeAgentInput(raw: OCToolInput): AgentInput {
-	const result: AgentInput = {
-		description: str(raw, 'description', 'description'),
-		prompt: str(raw, 'prompt', 'prompt'),
-		subagent_type: str(raw, 'subagent_type', 'subagentType'),
-	};
-	const model = optStr(raw, 'model', 'model') as AgentInput['model'];
-	if (model != null) result.model = model;
-	const resume = optStr(raw, 'resume', 'resume');
-	if (resume != null) result.resume = resume;
-	const runInBackground = optBool(raw, 'run_in_background', 'runInBackground');
-	if (runInBackground != null) result.run_in_background = runInBackground;
-	const maxTurns = optNum(raw, 'max_turns', 'maxTurns');
-	if (maxTurns != null) result.max_turns = maxTurns;
-	return result;
-}
-
-function normalizeNotebookEditInput(raw: OCToolInput): NotebookEditInput {
-	const result: NotebookEditInput = {
-		notebook_path: str(raw, 'notebook_path', 'notebookPath'),
-		new_source: str(raw, 'new_source', 'newSource'),
-	};
-	const cellId = optStr(raw, 'cell_id', 'cellId');
-	if (cellId != null) result.cell_id = cellId;
-	const cellType = optStr(raw, 'cell_type', 'cellType') as NotebookEditInput['cell_type'];
-	if (cellType != null) result.cell_type = cellType;
-	const editMode = optStr(raw, 'edit_mode', 'editMode') as NotebookEditInput['edit_mode'];
-	if (editMode != null) result.edit_mode = editMode;
-	return result;
-}
-
-function normalizeKillShellInput(raw: OCToolInput): KillShellInput {
+function normalizeAskUserQuestionInput(raw: OCToolInput): AskUserQuestionInput {
 	return {
-		shell_id: str(raw, 'shell_id', 'shellId'),
+		questions: (raw.questions ?? []) as AskUserQuestionInput['questions'],
 	};
 }
 
@@ -333,27 +310,12 @@ function normalizeReadMcpResourceInput(raw: OCToolInput): ReadMcpResourceInput {
 	};
 }
 
-function normalizeTaskOutputInput(raw: OCToolInput): TaskOutputInput {
-	return {
-		task_id: str(raw, 'task_id', 'taskId'),
-		block: (raw.block ?? true) as boolean,
-		timeout: (raw.timeout ?? 30000) as number,
-	};
-}
-
 function normalizeTodoWriteInput(raw: OCToolInput): TodoWriteInput {
 	return {
 		todos: (raw.todos ?? []) as TodoWriteInput['todos'],
 	};
 }
 
-function normalizeExitPlanModeInput(raw: OCToolInput): ExitPlanModeInput {
-	const result: ExitPlanModeInput = {};
-	const allowedPrompts = raw.allowedPrompts ?? raw.allowed_prompts;
-	if (allowedPrompts != null) result.allowedPrompts = allowedPrompts as ExitPlanModeInput['allowedPrompts'];
-	return result;
-}
-
 // ============================================================
 // Normalizer Dispatcher
 // ============================================================
@@ -362,10 +324,10 @@ function normalizeExitPlanModeInput(raw: OCToolInput): ExitPlanModeInput {
  * Normalize OpenCode tool input → Claude Code tool input format.
  * Handles camelCase → snake_case conversion and field name differences.
  */
-function normalizeToolInput(claudeToolName: string, raw: OCToolInput): ClaudeToolInput {
+function normalizeToolInput(claudeToolName: string, raw: OCToolInput): NormalizedToolInput {
 	// Custom MCP tools (mcp__*) — pass input through as-is
 	if (claudeToolName.startsWith('mcp__')) {
-		return raw as ClaudeToolInput;
+		return raw as NormalizedToolInput;
 	}
 
 	switch (claudeToolName) {
@@ -377,21 +339,17 @@ function normalizeToolInput(claudeToolName: string, raw: OCToolInput): ClaudeToo
 		case 'Grep': return normalizeGrepInput(raw);
 		case 'WebFetch': return normalizeWebFetchInput(raw);
 		case 'WebSearch': return normalizeWebSearchInput(raw);
-		case 'Task': return normalizeAgentInput(raw);
-		case 'NotebookEdit': return normalizeNotebookEditInput(raw);
-		case 'KillShell': return normalizeKillShellInput(raw);
+		case 'AskUserQuestion': return normalizeAskUserQuestionInput(raw);
 		case 'ListMcpResources': return normalizeListMcpResourcesInput(raw);
 		case 'ReadMcpResource': return normalizeReadMcpResourceInput(raw);
-		case 'TaskOutput': return normalizeTaskOutputInput(raw);
 		case 'TodoWrite': return normalizeTodoWriteInput(raw);
-		case 'ExitPlanMode': return normalizeExitPlanModeInput(raw);
 		default: {
 			// Unknown tool: generic camelCase → snake_case key normalization
 			const normalized: Record<string, string | number | boolean> = {};
 			for (const [key, value] of Object.entries(raw)) {
 				normalized[camelToSnake(key)] = value as string | number | boolean;
 			}
-			return normalized as ClaudeToolInput;
+			return normalized as NormalizedToolInput;
 		}
 	}
 }

package/backend/lib/engine/types.ts

@@ -55,4 +55,10 @@ export interface AIEngine {
 
 	/** Return the list of models this engine supports */
 	getAvailableModels(): Promise<EngineModel[]>;
+
+	/**
+	 * Resolve a pending AskUserQuestion by providing the user's answers.
+	 * Unblocks the canUseTool callback so the SDK can continue.
+	 */
+	resolveUserAnswer?(toolUseId: string, answers: Record<string, string>): boolean;
 }

package/backend/lib/files/file-operations.ts

@@ -10,9 +10,9 @@ const { spawn } = Bun;
 async function readdir(path: string): Promise<string[]> {
 	let proc;
 	if (process.platform === 'win32') {
-		proc = Bun.spawn(['cmd', '/c', 'dir', '/b', path], { stdout: 'pipe', stderr: 'ignore' });
+		proc = Bun.spawn(['cmd', '/c', 'dir', '/b', '/a', path], { stdout: 'pipe', stderr: 'ignore' });
 	} else {
-		proc = Bun.spawn(['ls', '-1', path], { stdout: 'pipe', stderr: 'ignore' });
+		proc = Bun.spawn(['ls', '-1A', path], { stdout: 'pipe', stderr: 'ignore' });
 	}
 	const result = await new Response(proc.stdout).text();
 	// Split and clean up, removing \r characters for Windows compatibility

package/backend/lib/files/file-reading.ts

@@ -7,9 +7,9 @@ import { debug } from '$shared/utils/logger';
 async function readdir(path: string): Promise<string[]> {
 	let proc;
 	if (process.platform === 'win32') {
-		proc = Bun.spawn(['cmd', '/c', 'dir', '/b', path], { stdout: 'pipe', stderr: 'ignore' });
+		proc = Bun.spawn(['cmd', '/c', 'dir', '/b', '/a', path], { stdout: 'pipe', stderr: 'ignore' });
 	} else {
-		proc = Bun.spawn(['ls', '-1', path], { stdout: 'pipe', stderr: 'ignore' });
+		proc = Bun.spawn(['ls', '-1A', path], { stdout: 'pipe', stderr: 'ignore' });
 	}
 	const result = await new Response(proc.stdout).text();
 	// Split and clean up, removing \r characters for Windows compatibility

package/backend/lib/files/path-browsing.ts

@@ -6,9 +6,9 @@ import { debug } from '$shared/utils/logger';
 async function readdir(path: string): Promise<string[]> {
 	let proc;
 	if (process.platform === 'win32') {
-		proc = Bun.spawn(['cmd', '/c', 'dir', '/b', path], { stdout: 'pipe', stderr: 'ignore' });
+		proc = Bun.spawn(['cmd', '/c', 'dir', '/b', '/a', path], { stdout: 'pipe', stderr: 'ignore' });
 	} else {
-		proc = Bun.spawn(['ls', '-1', path], { stdout: 'pipe', stderr: 'ignore' });
+		proc = Bun.spawn(['ls', '-1A', path], { stdout: 'pipe', stderr: 'ignore' });
 	}
 	const result = await new Response(proc.stdout).text();
 	// Split and clean up, removing \r characters for Windows compatibility

package/backend/lib/terminal/pty-session-manager.ts

@@ -61,7 +61,7 @@ class PtySessionManager {
 
 		if (isWindows) {
 			// Windows: Use PowerShell in interactive mode
-			shell = 'powershell';
+			shell = 'powershell.exe';
 			shellArgs = ['-NoLogo']; // Interactive mode, no -Command
 		} else {
 			// Unix: Use user's default shell or bash