src-tauri/src/commands.rs

@@ -105,6 +105,51 @@ pub async fn get_usage_stats(
     manager.get_usage_stats(&conversation_id)
 }
 
+#[tauri::command]
+pub async fn validate_directory(path: String, current_dir: Option<String>) -> Result<String, String> {
+    use std::path::Path;
+
+    let path = Path::new(&path);
+
+    // Expand ~ to home directory
+    let expanded_path = if path.starts_with("~") {
+        if let Some(home) = std::env::var_os("HOME") {
+            let home_path = Path::new(&home);
+            if path == Path::new("~") {
+                home_path.to_path_buf()
+            } else {
+                home_path.join(path.strip_prefix("~").unwrap())
+            }
+        } else {
+            return Err("Could not determine home directory".to_string());
+        }
+    } else if path.is_relative() {
+        // Handle relative paths (., .., or any relative path) by resolving against current_dir
+        if let Some(ref cwd) = current_dir {
+            Path::new(cwd).join(path)
+        } else {
+            path.to_path_buf()
+        }
+    } else {
+        path.to_path_buf()
+    };
+
+    // Check if the path exists and is a directory
+    if !expanded_path.exists() {
+        return Err(format!("Directory does not exist: {}", expanded_path.display()));
+    }
+
+    if !expanded_path.is_dir() {
+        return Err(format!("Path is not a directory: {}", expanded_path.display()));
+    }
+
+    // Return the canonicalized (absolute) path
+    expanded_path
+        .canonicalize()
+        .map(|p| p.to_string_lossy().to_string())
+        .map_err(|e| format!("Failed to resolve path: {}", e))
+}
+
 #[tauri::command]
 pub async fn load_saved_achievements(app: AppHandle) -> Result<Vec<AchievementUnlockedEvent>, String> {
     use chrono::Utc;

src-tauri/src/config.rs

@@ -22,6 +22,9 @@ pub struct ClaudeStartOptions {
 
     #[serde(default)]
     pub skip_greeting: bool,
+
+    #[serde(default)]
+    pub resume_session_id: Option<String>,
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize)]

src-tauri/src/lib.rs

@@ -53,6 +53,7 @@ pub fn run() {
             send_notify_send,
             send_wsl_notification,
             send_vbs_notification,
+            validate_directory,
         ])
         .run(tauri::generate_context!())
         .expect("error while running tauri application");

src-tauri/src/wsl_bridge.rs

@@ -195,6 +195,13 @@ impl WslBridge {
                 cmd.args(["--mcp-config", mcp_path]);
             }
 
+            // Add resume flag if session ID provided
+            if let Some(ref session_id) = options.resume_session_id {
+                if !session_id.is_empty() {
+                    cmd.args(["--resume", session_id]);
+                }
+            }
+
             cmd.current_dir(working_dir);
 
             // Set API key as environment variable if specified
@@ -251,6 +258,13 @@ impl WslBridge {
                 claude_cmd.push_str(&format!(" --mcp-config '{}'", mcp_path));
             }
 
+            // Add resume flag if session ID provided
+            if let Some(ref session_id) = options.resume_session_id {
+                if !session_id.is_empty() {
+                    claude_cmd.push_str(&format!(" --resume '{}'", session_id));
+                }
+            }
+
             // Use bash -lc to load login profile (ensures PATH includes claude)
             cmd.args(["-e", "bash", "-lc", &claude_cmd]);
 

src/lib/commands/slashCommands.ts

@@ -3,6 +3,7 @@ import { invoke } from "@tauri-apps/api/core";
 import { claudeStore } from "$lib/stores/claude";
 import { characterState } from "$lib/stores/character";
 import { setSkipNextGreeting } from "$lib/tauri";
+import { searchState } from "$lib/stores/search";
 
 export interface SlashCommand {
   name: string;
@@ -11,6 +12,71 @@ export interface SlashCommand {
   execute: (args: string) => Promise<void> | void;
 }
 
+async function changeDirectory(path: string): Promise<void> {
+  const conversationId = get(claudeStore.activeConversationId);
+  if (!conversationId) {
+    claudeStore.addLine("error", "No active conversation");
+    return;
+  }
+
+  if (!path.trim()) {
+    const currentDir = get(claudeStore.currentWorkingDirectory);
+    claudeStore.addLine("system", `Current directory: ${currentDir}`);
+    return;
+  }
+
+  try {
+    characterState.setState("thinking");
+    claudeStore.addLine("system", `Changing directory to: ${path}`);
+
+    const currentDir = get(claudeStore.currentWorkingDirectory);
+    const validatedPath = await invoke<string>("validate_directory", { path, currentDir });
+
+    // Capture conversation history before disconnecting
+    const conversationHistory = claudeStore.getConversationHistory();
+
+    await invoke("stop_claude", { conversationId });
+
+    // Wait for clean shutdown
+    await new Promise((resolve) => setTimeout(resolve, 500));
+
+    claudeStore.setWorkingDirectory(validatedPath);
+
+    setSkipNextGreeting(true);
+
+    await invoke("start_claude", {
+      conversationId,
+      options: {
+        working_dir: validatedPath,
+      },
+    });
+
+    // Wait for connection to establish
+    await new Promise((resolve) => setTimeout(resolve, 1000));
+
+    // Restore context if there was conversation history
+    if (conversationHistory) {
+      const contextMessage = `[CONTEXT RESTORATION]
+I just changed the working directory from ${currentDir} to ${validatedPath}. Here's our conversation so far:
+
+${conversationHistory}
+
+Please continue where we left off. You are now operating in the new directory.`;
+
+      await invoke("send_prompt", {
+        conversationId,
+        message: contextMessage,
+      });
+    }
+
+    claudeStore.addLine("system", `Changed directory to: ${validatedPath}`);
+    characterState.setState("idle");
+  } catch (error) {
+    claudeStore.addLine("error", `Failed to change directory: ${error}`);
+    characterState.setTemporaryState("error", 3000);
+  }
+}
+
 async function startNewConversation(): Promise<void> {
   const conversationId = get(claudeStore.activeConversationId);
   if (!conversationId) {
@@ -48,6 +114,12 @@ async function startNewConversation(): Promise<void> {
 }
 
 export const slashCommands: SlashCommand[] = [
+  {
+    name: "cd",
+    description: "Change the working directory",
+    usage: "/cd <path>",
+    execute: changeDirectory,
+  },
   {
     name: "clear",
     description: "Clear the terminal display (keeps conversation context)",
@@ -74,6 +146,20 @@ export const slashCommands: SlashCommand[] = [
       claudeStore.addLine("system", `Available commands:\n${helpText}`);
     },
   },
+  {
+    name: "search",
+    description: "Search within the conversation (use /search to clear)",
+    usage: "/search [query]",
+    execute: (args: string) => {
+      if (!args.trim()) {
+        searchState.clear();
+        claudeStore.addLine("system", "Search cleared");
+        return;
+      }
+      searchState.setQuery(args.trim());
+      claudeStore.addLine("system", `Searching for: "${args.trim()}"`);
+    },
+  },
   {
     name: "summarise",
     description: "Get a summary of the entire conversation",

src/lib/components/ConversationTabs.svelte

@@ -126,6 +126,8 @@
     } else if (event.key === "Escape") {
       editingTabId = null;
       editingName = "";
+    } else if (event.key === " ") {
+      event.stopPropagation();
     }
   }
 

src/lib/components/HighlightedText.svelte

@@ -0,0 +1,61 @@
+<script lang="ts">
+  export let content: string;
+  export let searchQuery: string;
+
+  interface TextPart {
+    text: string;
+    isMatch: boolean;
+  }
+
+  function getHighlightedParts(text: string, query: string): TextPart[] {
+    if (!query) {
+      return [{ text, isMatch: false }];
+    }
+
+    const escapedQuery = query.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const regex = new RegExp(`(${escapedQuery})`, "gi");
+    const parts: TextPart[] = [];
+    let lastIndex = 0;
+    let match: RegExpExecArray | null;
+
+    while ((match = regex.exec(text)) !== null) {
+      // Add non-matching text before the match
+      if (match.index > lastIndex) {
+        parts.push({
+          text: text.slice(lastIndex, match.index),
+          isMatch: false,
+        });
+      }
+
+      // Add the matching text
+      parts.push({
+        text: match[1],
+        isMatch: true,
+      });
+
+      lastIndex = regex.lastIndex;
+    }
+
+    // Add any remaining text after the last match
+    if (lastIndex < text.length) {
+      parts.push({
+        text: text.slice(lastIndex),
+        isMatch: false,
+      });
+    }
+
+    return parts;
+  }
+
+  $: parts = getHighlightedParts(content, searchQuery);
+</script>
+
+<span class="whitespace-pre-wrap">
+  {#each parts as part, index (index)}
+    {#if part.isMatch}
+      <mark class="search-highlight">{part.text}</mark>
+    {:else}
+      {part.text}
+    {/if}
+  {/each}
+</span>

src/lib/components/Markdown.svelte

@@ -2,12 +2,14 @@
   import { marked } from "marked";
   import hljs from "highlight.js";
   import { onMount } from "svelte";
+  import { openUrl } from "@tauri-apps/plugin-opener";
 
   interface Props {
     content: string;
+    searchQuery?: string;
   }
 
-  let { content }: Props = $props();
+  let { content, searchQuery = "" }: Props = $props();
   let containerElement: HTMLDivElement;
 
   const renderer = new marked.Renderer();
@@ -51,10 +53,47 @@
     return processed;
   }
 
+  function highlightSearchMatches(html: string, query: string): string {
+    if (!query) return html;
+
+    const codeBlockPlaceholders: string[] = [];
+    const tagPlaceholders: string[] = [];
+
+    // Temporarily replace code blocks with placeholders (don't highlight in code)
+    let processed = html.replace(/<(pre|code)[^>]*>[\s\S]*?<\/\1>/gi, (match) => {
+      codeBlockPlaceholders.push(match);
+      return `__CODE_SEARCH_PLACEHOLDER_${codeBlockPlaceholders.length - 1}__`;
+    });
+
+    // Temporarily replace all HTML tags with placeholders
+    processed = processed.replace(/<[^>]+>/g, (match) => {
+      tagPlaceholders.push(match);
+      return `__TAG_PLACEHOLDER_${tagPlaceholders.length - 1}__`;
+    });
+
+    // Apply search highlighting to text content
+    const escapedQuery = query.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const regex = new RegExp(`(${escapedQuery})`, "gi");
+    processed = processed.replace(regex, '<mark class="search-highlight">$1</mark>');
+
+    // Restore HTML tags
+    processed = processed.replace(/__TAG_PLACEHOLDER_(\d+)__/g, (_, index) => {
+      return tagPlaceholders[parseInt(index)];
+    });
+
+    // Restore code blocks
+    processed = processed.replace(/__CODE_SEARCH_PLACEHOLDER_(\d+)__/g, (_, index) => {
+      return codeBlockPlaceholders[parseInt(index)];
+    });
+
+    return processed;
+  }
+
   function renderMarkdown(text: string): string {
     try {
       const html = marked.parse(text) as string;
-      return processSpoilers(html);
+      const withSpoilers = processSpoilers(html);
+      return highlightSearchMatches(withSpoilers, searchQuery);
     } catch {
       return text;
     }
@@ -75,6 +114,15 @@
     }
   }
 
+  function handleLinkClick(event: MouseEvent) {
+    const target = event.target as HTMLElement;
+    const anchor = target.closest("a");
+    if (anchor?.href) {
+      event.preventDefault();
+      openUrl(anchor.href);
+    }
+  }
+
   onMount(() => {
     if (containerElement) {
       containerElement.querySelectorAll("pre code:not(.hljs)").forEach((block) => {
@@ -87,7 +135,10 @@
 <div
   bind:this={containerElement}
   class="markdown-content"
-  onclick={handleSpoilerClick}
+  onclick={(e) => {
+    handleSpoilerClick(e);
+    handleLinkClick(e);
+  }}
   onkeydown={handleSpoilerKeydown}
   role="presentation"
 >
@@ -291,4 +342,11 @@
     color: var(--text-primary);
     user-select: text;
   }
+
+  .markdown-content :global(.search-highlight) {
+    background-color: var(--search-highlight, #fbbf24);
+    color: var(--search-highlight-text, #000);
+    border-radius: 2px;
+    padding: 0 2px;
+  }
 </style>

src/lib/components/Terminal.svelte

@@ -3,10 +3,17 @@
   import { afterUpdate } from "svelte";
   import ConversationTabs from "./ConversationTabs.svelte";
   import Markdown from "./Markdown.svelte";
+  import HighlightedText from "./HighlightedText.svelte";
+  import { searchState, searchQuery } from "$lib/stores/search";
 
   let terminalElement: HTMLDivElement;
   let shouldAutoScroll = true;
   let lines: TerminalLine[] = [];
+  let currentSearchQuery = "";
+
+  searchQuery.subscribe((value) => {
+    currentSearchQuery = value;
+  });
 
   claudeStore.terminalLines.subscribe((value) => {
     lines = value;
@@ -64,6 +71,23 @@
       minute: "2-digit",
     });
   }
+
+  $: {
+    if (currentSearchQuery && lines.length > 0) {
+      const escapedQuery = currentSearchQuery.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+      const regex = new RegExp(escapedQuery, "gi");
+      let totalMatches = 0;
+      for (const line of lines) {
+        const matches = line.content.match(regex);
+        if (matches) {
+          totalMatches += matches.length;
+        }
+      }
+      searchState.setMatchCount(totalMatches);
+    } else {
+      searchState.setMatchCount(0);
+    }
+  }
 </script>
 
 <div
@@ -102,9 +126,9 @@
             <span class="terminal-tool-name mr-2">[{line.toolName}]</span>
           {/if}
           {#if line.type === "assistant"}
-            <Markdown content={line.content} />
+            <Markdown content={line.content} searchQuery={currentSearchQuery} />
           {:else}
-            <span class="whitespace-pre-wrap">{line.content}</span>
+            <HighlightedText content={line.content} searchQuery={currentSearchQuery} />
           {/if}
         </div>
       {/each}
@@ -162,4 +186,11 @@
   .terminal-header-text {
     color: var(--text-secondary);
   }
+
+  :global(.search-highlight) {
+    background-color: var(--search-highlight, #fbbf24);
+    color: var(--search-highlight-text, #000);
+    border-radius: 2px;
+    padding: 0 2px;
+  }
 </style>

src/lib/stores/search.ts

@@ -0,0 +1,63 @@
+import { writable, derived } from "svelte/store";
+
+interface SearchState {
+  query: string;
+  isActive: boolean;
+  matchCount: number;
+  currentMatchIndex: number;
+}
+
+const initialState: SearchState = {
+  query: "",
+  isActive: false,
+  matchCount: 0,
+  currentMatchIndex: 0,
+};
+
+const searchStore = writable<SearchState>(initialState);
+
+export const searchState = {
+  subscribe: searchStore.subscribe,
+
+  setQuery: (query: string) => {
+    searchStore.update((state) => ({
+      ...state,
+      query,
+      isActive: query.length > 0,
+      currentMatchIndex: 0,
+    }));
+  },
+
+  setMatchCount: (count: number) => {
+    searchStore.update((state) => ({
+      ...state,
+      matchCount: count,
+    }));
+  },
+
+  nextMatch: () => {
+    searchStore.update((state) => ({
+      ...state,
+      currentMatchIndex:
+        state.matchCount > 0 ? (state.currentMatchIndex + 1) % state.matchCount : 0,
+    }));
+  },
+
+  previousMatch: () => {
+    searchStore.update((state) => ({
+      ...state,
+      currentMatchIndex:
+        state.matchCount > 0
+          ? (state.currentMatchIndex - 1 + state.matchCount) % state.matchCount
+          : 0,
+    }));
+  },
+
+  clear: () => {
+    searchStore.set(initialState);
+  },
+};
+
+export const isSearchActive = derived(searchStore, ($search) => $search.isActive);
+
+export const searchQuery = derived(searchStore, ($search) => $search.query);