iris-chatbot 4.0.0 → 4.1.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "iris-chatbot",
-  "version": "4.0.0",
+  "version": "4.1.0",
   "private": false,
   "description": "One-command installer for the Iris project template.",
   "bin": {

package/template/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "iris",
-  "version": "4.0.0",
+  "version": "4.1.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "iris",
-      "version": "4.0.0",
+      "version": "4.1.0",
       "dependencies": {
         "@anthropic-ai/sdk": "^0.72.1",
         "clsx": "^2.1.1",

package/template/package.json

@@ -1,6 +1,6 @@
 {
   "name": "iris",
-  "version": "4.0.0",
+  "version": "4.1.0",
   "private": true,
   "description": "One-command installer for the Iris project template.",
   "engines": {

package/template/src/app/api/chat/route.ts

@@ -42,25 +42,26 @@ const LOCAL_TOOL_SYSTEM_INSTRUCTIONS = [
   "When the user asks for file, app, notes, music, web, calendar, or system actions, call tools directly.",
   "Default to execution instead of clarification. Ask at most one question only when a truly required value is missing.",
   "Calendar: You have direct access to the user's Apple Calendar via calendar_list_events and related tools. You CAN see their events—call the tools; do not say you cannot access or see their calendar. Never ask the user to paste their calendar, export it, or send a screenshot; you already have access. When they ask what's on the calendar, what's happening this/next weekend/month, or say 'check' or 'you can see', call calendar_list_events immediately with from/to for the range (e.g. next month → from: 'today', to: 'end of next month'; specific day → YYYY-MM-DD for both). Always pass calendar: 'all'. from/to support 'today', 'tomorrow', 'next week', 'end of next week', 'next month', 'end of next month'. Report the exact queried range from the tool result. For move/delete/reschedule: call calendar_list_events first to get uids. For rescheduling to a new time on the same calendar use calendar_update_event (preserves recurrence); for delete use calendar_delete_event; use calendar_move_event only when update is not sufficient (e.g. user says move and you need delete+recreate).",
+  "Files and Folders: You HAVE direct access to the user's files via file_list and file_find. Never say you cannot see, access, or list their files—call the tools. When the user asks 'what files do I have,' 'files from the last 7 days,' 'recent files,' or similar: call file_list immediately with path set to a folder (e.g. ~/Downloads, ~/Desktop, ~/Documents—or call once per root if you want all) and modifiedInLastDays: 7 (or the number of days they said). You have full file system access via file_list, file_mkdir, file_move, file_copy, file_delete_to_trash, file_batch_move, and file_find. When the user gives a folder or file name (e.g. 'us debt clock'), use file_find with searchPath '~' and the name as given. When moving MULTIPLE files, use file_batch_move with { operations: [ ... ] } or { destination, sources }. For organizing: file_find if location unknown, then file_list (use modifiedInLastDays for 'recent'), then file_mkdir/file_batch_move as needed. Never refuse file tasks or ask the user to use Finder manually—you have the tools.",
   "For iMessage/text requests, use messages_send; if contact matching is ambiguous, ask one concise clarification with candidate names.",
   "For media requests, assume Apple Music unless the user specifies otherwise.",
   "For note creation, write structured markdown with clear headings, bolded key labels, and tables when they improve clarity.",
   "If the user requests multiple actions in one prompt, execute every requested action sequentially before your final response.",
   "Do not stop after completing just one action when additional requested actions remain.",
   "For multi-step requests, prefer a single workflow tool call when available.",
-  "When tools are enabled, never claim you cannot access the user's device or calendar. You have calendar tools—use them; do not refuse or ask the user to paste/export/screenshot their calendar.",
+  "When tools are enabled, never claim you cannot access the user's device, calendar, or file system. You have the tools—use them; do not refuse or ask the user to do tasks manually that you can do with tools.",
   "After tool results arrive, provide a brief final answer and stop.",
   "Summarize tool activity in plain English and avoid raw JSON, stack traces, or script line numbers.",
   "Respect tool errors and provide clear next steps.",
 ].join(" ");
 
 const ACTION_VERB_PATTERN =
-  "create|make|write|play|set|add|remind|open|send|launch|start|pause|resume|focus";
+  "create|make|write|play|set|add|remind|open|send|launch|start|pause|resume|focus|move|copy|delete|organize|reorganize|restructure|split|separate|sort|categorize";
 const SEQUENCE_MARKER_PATTERN = "first|second|third|fourth|fifth|next|then|finally|lastly";
 const TOOL_INTENT_EXPLICIT_PATTERN =
   /\b(use|run|call)\s+(?:the\s+)?(?:local\s+)?tools?\b|\b(on my (?:mac|computer|device)|locally)\b/i;
 const TOOL_INTENT_LEADING_VERB_PATTERN =
-  /^(?:please\s+)?(?:(?:can|could|would)\s+you\s+)?(?:send|text|message|play|pause|resume|skip|next|previous|set|open|launch|focus|create|make|add|remind|search|find|list|move|copy|rename|delete|trash|append|write|read|start|stop)\b/i;
+  /^(?:please\s+)?(?:(?:can|could|would)\s+you\s+)?(?:send|text|message|play|pause|resume|skip|next|previous|set|open|launch|focus|create|make|add|remind|search|find|list|move|copy|rename|delete|trash|append|write|read|start|stop|organize|reorganize|restructure|split|separate|sort|categorize|put|place)(?:\s+|$)/i;
 const TOOL_INTENT_MESSAGING_PATTERN =
   /\b(text|message|imessage|sms|mail|email)\b[\s\S]{0,80}\b(send|text|message|email|mail)\b|\b(send|text|message|email|mail)\b[\s\S]{0,80}\b(text|message|imessage|sms|mail|email)\b/i;
 const TOOL_INTENT_NOTES_PATTERN =
@@ -70,7 +71,7 @@ const TOOL_INTENT_MUSIC_PATTERN =
 const TOOL_INTENT_SCHEDULE_PATTERN =
   /\b(calendar|event|reminder|schedule|events)\b[\s\S]{0,80}\b(create|add|list|show|set|remind|schedule|move|change|delete|reschedule|update|cancel|have|get|check)\b|\b(create|add|list|show|set|remind|schedule|move|change|delete|reschedule|update|cancel|have|get|check)\b[\s\S]{0,80}\b(calendar|event|reminder|schedule|events)\b|\b(move|reschedule|change|delete)\b[\s\S]{0,80}\b(event|meeting|appointment)\b|\b(what's happening|whats happening|what's on|whats on|next weekend|this weekend|you can see|just check)\b/i;
 const TOOL_INTENT_FILES_PATTERN =
-  /\b(file|folder|directory|path|document)\b[\s\S]{0,80}\b(list|find|search|move|copy|rename|delete|trash|create|make|mkdir|open)\b|\b(list|find|search|move|copy|rename|delete|trash|create|make|mkdir|open)\b[\s\S]{0,80}\b(file|folder|directory|path|document)\b/i;
+  /\b(file|folder|directory|path|document|subfolder|subfolders)\b[\s\S]{0,80}\b(list|find|search|move|copy|rename|delete|trash|create|make|mkdir|open|organize|reorganize|restructure|split|separate|sort|categorize|put|place|have|show|see|get)\b|\b(list|find|search|move|copy|rename|delete|trash|create|make|mkdir|open|organize|reorganize|restructure|split|separate|sort|categorize|put|place|have|show|see|get)\b[\s\S]{0,80}\b(file|folder|directory|path|document|subfolder|subfolders)\b|\b(organize|reorganize|restructure|split|separate)\b[\s\S]{0,80}\b(into|by|by type|by date|by name)\b|\b(put|move|place)\b[\s\S]{0,40}\b(into|in|inside)\b[\s\S]{0,40}\b(folder|directory)\b|\b(create|make)\b[\s\S]{0,40}\b(folders?|directories?)\b[\s\S]{0,40}\b(for|called|named)\b|\b(recent|last \d+|past \d+)\b[\s\S]{0,40}\b(files?|days?|weeks?)\b|\b(files?)\b[\s\S]{0,40}\b(from|in|within|during)\b[\s\S]{0,40}\b(last|past|recent|\d+)\b|\b(what|which|show|list|my)\b[\s\S]{0,40}\b(files?|documents?)\b/i;
 const TOOL_INTENT_APPS_PATTERN =
   /\b(app|application|window|url|website|browser|system)\b[\s\S]{0,80}\b(open|launch|focus|quit|set|mute|unmute|browse)\b|\b(open|launch|focus|quit|set|mute|unmute|browse)\b[\s\S]{0,80}\b(app|application|window|url|website|browser|system)\b/i;
 const TOOL_INTENT_NUMBERS_PATTERN =
@@ -86,8 +87,8 @@ function splitCompoundActionClauses(input: string): string[] {
   const roughParts = normalized.split(
     new RegExp(
       `\\s*(?:,|;|\\n)+\\s*(?=(?:(?:${SEQUENCE_MARKER_PATTERN})\\b|${ACTION_VERB_PATTERN}\\b))|` +
-        `\\s+(?:and then|and also|as well as|after that|plus|then|also|next|finally|lastly)\\s+|` +
-        `\\s+and\\s+(?=(?:${ACTION_VERB_PATTERN})\\b)`,
+      `\\s+(?:and then|and also|as well as|after that|plus|then|also|next|finally|lastly)\\s+|` +
+      `\\s+and\\s+(?=(?:${ACTION_VERB_PATTERN})\\b)`,
       "i",
     ),
   );
@@ -234,9 +235,9 @@ function normalizeRuntimeConnection(connection: ChatConnectionPayload): RuntimeC
       : "openai_compatible";
   const provider =
     kind === "builtin" &&
-    (connection.provider === "openai" ||
-      connection.provider === "anthropic" ||
-      connection.provider === "google")
+      (connection.provider === "openai" ||
+        connection.provider === "anthropic" ||
+        connection.provider === "google")
       ? connection.provider
       : undefined;
   const baseUrl =
@@ -264,9 +265,9 @@ function normalizeRuntimeConnection(connection: ChatConnectionPayload): RuntimeC
     apiKey,
     headers: Array.isArray(connection.headers)
       ? connection.headers.filter(
-          (header): header is { key: string; value: string } =>
-            Boolean(header) && typeof header.key === "string" && typeof header.value === "string",
-        )
+        (header): header is { key: string; value: string } =>
+          Boolean(header) && typeof header.key === "string" && typeof header.value === "string",
+      )
       : [],
     supportsTools,
   };
@@ -435,47 +436,47 @@ function sanitizeMemoryContext(
 
   const people = Array.isArray(aliases.people)
     ? aliases.people
-        .map((item) => {
-          const alias = typeof item?.alias === "string" ? item.alias.trim() : "";
-          const target = typeof item?.target === "string" ? item.target.trim() : "";
-          if (!alias || !target) {
-            return null;
-          }
-          return { alias, target };
-        })
-        .filter((item): item is { alias: string; target: string } => Boolean(item))
-        .slice(0, 16)
+      .map((item) => {
+        const alias = typeof item?.alias === "string" ? item.alias.trim() : "";
+        const target = typeof item?.target === "string" ? item.target.trim() : "";
+        if (!alias || !target) {
+          return null;
+        }
+        return { alias, target };
+      })
+      .filter((item): item is { alias: string; target: string } => Boolean(item))
+      .slice(0, 16)
     : [];
 
   const music = Array.isArray(aliases.music)
     ? aliases.music
-        .map((item) => {
-          const alias = typeof item?.alias === "string" ? item.alias.trim() : "";
-          const query = typeof item?.query === "string" ? item.query.trim() : "";
-          if (!alias || !query) {
-            return null;
-          }
-          const title =
-            typeof item?.title === "string" && item.title.trim()
-              ? item.title.trim()
-              : undefined;
-          const artist =
-            typeof item?.artist === "string" && item.artist.trim()
-              ? item.artist.trim()
-              : undefined;
-          return { alias, query, title, artist };
-        })
-        .filter(
-          (
-            item,
-          ): item is {
-            alias: string;
-            query: string;
-            title: string | undefined;
-            artist: string | undefined;
-          } => Boolean(item),
-        )
-        .slice(0, 16)
+      .map((item) => {
+        const alias = typeof item?.alias === "string" ? item.alias.trim() : "";
+        const query = typeof item?.query === "string" ? item.query.trim() : "";
+        if (!alias || !query) {
+          return null;
+        }
+        const title =
+          typeof item?.title === "string" && item.title.trim()
+            ? item.title.trim()
+            : undefined;
+        const artist =
+          typeof item?.artist === "string" && item.artist.trim()
+            ? item.artist.trim()
+            : undefined;
+        return { alias, query, title, artist };
+      })
+      .filter(
+        (
+          item,
+        ): item is {
+          alias: string;
+          query: string;
+          title: string | undefined;
+          artist: string | undefined;
+        } => Boolean(item),
+      )
+      .slice(0, 16)
     : [];
 
   return {
@@ -679,7 +680,7 @@ function humanizeToolErrorMessage(toolName: string, message: string): string {
   }
 
   if (normalized.includes("missing required")) {
-    const fieldMatch = cleaned.match(/missing required (?:string|numeric) field:\s*([a-zA-Z0-9_]+)/i);
+    const fieldMatch = cleaned.match(/missing required (?:string|numeric|array) field:\s*([a-zA-Z0-9_]+)/i);
     if (fieldMatch?.[1]) {
       return `Missing required field "${fieldMatch[1]}".`;
     }
@@ -1407,8 +1408,8 @@ async function tryDirectAutomationFastPath(params: {
       "Reminder";
     const title = sanitizeReminderTitle(
       rawTitle
-      .replace(/^(that|i have to|to|for)\s+/i, "")
-      .trim(),
+        .replace(/^(that|i have to|to|for)\s+/i, "")
+        .trim(),
     );
 
     return { title: title || "Reminder", due };
@@ -1715,18 +1716,18 @@ async function tryDirectAutomationFastPath(params: {
   const playResult =
     playOutput && typeof playOutput === "object"
       ? (playOutput as {
-          playing?: boolean;
-          matched?: boolean;
-          playlistName?: string | null;
-          title?: string | null;
-          artist?: string | null;
-          album?: string | null;
-          reason?: string | null;
-          matchedTitle?: string | null;
-          matchedArtist?: string | null;
-          catalogTitle?: string | null;
-          catalogArtist?: string | null;
-        })
+        playing?: boolean;
+        matched?: boolean;
+        playlistName?: string | null;
+        title?: string | null;
+        artist?: string | null;
+        album?: string | null;
+        reason?: string | null;
+        matchedTitle?: string | null;
+        matchedArtist?: string | null;
+        catalogTitle?: string | null;
+        catalogArtist?: string | null;
+      })
       : null;
 
   if (!playResult || playResult.playing !== true) {
@@ -1823,18 +1824,18 @@ async function tryDirectAutomationFastPath(params: {
   }
 
   params.send({
-      type: "token",
-      value:
-        hasNearbyMatch
-          ? `Started nearby match "${resolvedTitle}"${resolvedArtist ? ` by ${resolvedArtist}` : ""}. ${playResult.reason}`
-          : resolvedPlaylistName && intent.volume !== null
-            ? `**Done.** Playing playlist "${resolvedPlaylistName}" in Apple Music and set volume to ${intent.volume}%.`
-            : resolvedPlaylistName
-              ? `**Done.** Playing playlist "${resolvedPlaylistName}" in Apple Music.`
-          : intent.volume !== null
+    type: "token",
+    value:
+      hasNearbyMatch
+        ? `Started nearby match "${resolvedTitle}"${resolvedArtist ? ` by ${resolvedArtist}` : ""}. ${playResult.reason}`
+        : resolvedPlaylistName && intent.volume !== null
+          ? `**Done.** Playing playlist "${resolvedPlaylistName}" in Apple Music and set volume to ${intent.volume}%.`
+          : resolvedPlaylistName
+            ? `**Done.** Playing playlist "${resolvedPlaylistName}" in Apple Music.`
+            : intent.volume !== null
               ? `**Done.** Playing "${resolvedTitle}"${resolvedArtist ? ` by ${resolvedArtist}` : ""} in Apple Music and set volume to ${intent.volume}%.`
               : `**Done.** Playing "${resolvedTitle}"${resolvedArtist ? ` by ${resolvedArtist}` : ""} in Apple Music.`,
-    });
+  });
   return true;
 }
 
@@ -2159,12 +2160,12 @@ async function runToolOrchestrator(params: {
         const approval = createApprovalRequest();
         params.send({
           type: "approval_requested",
-            approvalId: approval.approvalId,
-            callId: call.id,
-            name: call.name,
-            args: callInput,
-            reason: summarizeApprovalReason(call.name, callInput),
-          });
+          approvalId: approval.approvalId,
+          callId: call.id,
+          name: call.name,
+          args: callInput,
+          reason: summarizeApprovalReason(call.name, callInput),
+        });
 
         emitThinkingUpdate(`Waiting for approval to run ${call.name}.`);
         const decision = await approval.promise;

package/template/src/app/page.tsx

@@ -344,7 +344,7 @@ export default function Home() {
         onSelect={async (id) => {
           if (id !== activeThreadId) {
             const prev = threads?.find((t) => t.id === activeThreadId);
-            if (prev?.headMessageId == null) {
+            if (prev && prev.headMessageId == null) {
               await deleteThread(prev.id);
             }
           }
@@ -352,7 +352,7 @@ export default function Home() {
         }}
         onNewChat={async () => {
           const prev = threads?.find((t) => t.id === activeThreadId);
-          if (prev?.headMessageId == null) {
+          if (prev && prev.headMessageId == null) {
             await deleteThread(prev.id);
           }
           const thread = await createNewThread();

package/template/src/components/MessageCard.tsx

@@ -19,6 +19,13 @@ import { splitContentAndSources } from "../lib/utils";
 
 const MAX_VISIBLE_TOOL_ITEMS = 8;
 const HIDDEN_TIMELINE_TOOLS = new Set(["tooling", "workflow_run"]);
+const FILE_FIND_ALLOWED_ROOTS_ERROR = "Path is outside allowed roots";
+
+function isHiddenFileFindError(event: ToolEvent): boolean {
+  if (event.toolName !== "file_find" || event.stage !== "result") return false;
+  const text = [event.message, event.payloadJson].filter(Boolean).join(" ");
+  return text.includes(FILE_FIND_ALLOWED_ROOTS_ERROR);
+}
 const TOOL_TIMELINE_DATE_FORMATTER = new Intl.DateTimeFormat("en-US", {
   month: "short",
   day: "numeric",
@@ -149,6 +156,8 @@ function humanizeToolName(toolName: string): string {
     file_copy: "Copy Item",
     file_mkdir: "Create Folder",
     file_delete_to_trash: "Move to Trash",
+    file_batch_move: "Move Files",
+    file_find: "Find Files",
     notes_create_or_append: "Update Note",
     notes_find: "Search Notes",
     app_open: "Open App",
@@ -265,7 +274,7 @@ function summarizeToolError(toolName: string, rawError: string): {
   if (normalized.includes("missing required")) {
     return {
       title: "Missing required information",
-      detail: "The action did not include all required fields.",
+      detail: cleaned.length < 200 ? cleaned : "The action did not include all required fields.",
     };
   }
 
@@ -365,6 +374,23 @@ function summarizeToolCall(toolName: string, payload: Record<string, unknown> |
     };
   }
 
+  if (toolName === "file_batch_move") {
+    const operations = payload.operations;
+    const count = Array.isArray(operations) ? operations.length : 0;
+    return {
+      title: count > 0 ? `Moving ${count} files` : "Moving files",
+    };
+  }
+
+  if (toolName === "file_find") {
+    const name = getString(payload, "name");
+    const searchPath = getString(payload, "searchPath");
+    return {
+      title: name ? `Searching for "${name}"` : "Searching for files",
+      detail: searchPath ? `In ${shortenPath(searchPath)}` : undefined,
+    };
+  }
+
   return { title: "Preparing action" };
 }
 
@@ -459,9 +485,9 @@ function summarizeToolResult(toolName: string, payload: Record<string, unknown>
       const detail = queriedRange
         ? queriedRange
         : joinDetailParts([
-            fromResolved ? `From: ${formatDateTime(fromResolved) ?? fromResolved}` : null,
-            toResolved ? `To: ${formatDateTime(toResolved) ?? toResolved}` : null,
-          ]);
+          fromResolved ? `From: ${formatDateTime(fromResolved) ?? fromResolved}` : null,
+          toResolved ? `To: ${formatDateTime(toResolved) ?? toResolved}` : null,
+        ]);
       return {
         title:
           count === 0
@@ -559,6 +585,46 @@ function summarizeToolResult(toolName: string, payload: Record<string, unknown>
     };
   }
 
+  if (toolName === "file_batch_move") {
+    const movedCount = getNumber(payload, "movedCount");
+    const failedCount = getNumber(payload, "failedCount");
+    const totalOps = getNumber(payload, "totalOperations");
+    if (movedCount !== null && failedCount !== null) {
+      if (failedCount === 0) {
+        return {
+          title: `Moved ${movedCount} files successfully`,
+        };
+      }
+      return {
+        title: `Moved ${movedCount} files`,
+        detail: `${failedCount} failed`,
+      };
+    }
+    if (totalOps !== null) {
+      return { title: `Processed ${totalOps} files` };
+    }
+  }
+
+  if (toolName === "file_find") {
+    const totalFound = getNumber(payload, "totalFound");
+    const searchName = getString(payload, "searchName");
+    const matches = payload.matches;
+    const topMatch = Array.isArray(matches) && matches.length > 0 ? matches[0] as Record<string, unknown> : null;
+    const topMatchPath = topMatch ? getString(topMatch, "path") : null;
+
+    if (totalFound !== null) {
+      if (totalFound === 0) {
+        return {
+          title: searchName ? `No matches for "${searchName}"` : "No matches found",
+        };
+      }
+      return {
+        title: `Found ${totalFound} match${totalFound === 1 ? "" : "es"}`,
+        detail: topMatchPath ? `Best match: ${shortenPath(topMatchPath)}` : undefined,
+      };
+    }
+  }
+
   return { title: "Completed successfully" };
 }
 
@@ -673,6 +739,7 @@ function MessageCard({
     () =>
       (toolEvents ?? [])
         .filter((event) => !HIDDEN_TIMELINE_TOOLS.has(event.toolName))
+        .filter((event) => !isHiddenFileFindError(event))
         .slice()
         .sort((a, b) => a.createdAt - b.createdAt),
     [toolEvents],
@@ -874,9 +941,8 @@ function MessageCard({
             {shelfThreads.map((thread) => (
               <div key={thread.id} className="thread-box-wrap">
                 <button
-                  className={`thread-box ${
-                    activeThreadId === thread.id ? "active" : ""
-                  }`}
+                  className={`thread-box ${activeThreadId === thread.id ? "active" : ""
+                    }`}
                   onClick={() => onSelectThread(thread.id)}
                 >
                   {thread.title}
@@ -903,11 +969,10 @@ function MessageCard({
       >
         {isAssistant ? (
           <button
-            className={`flex items-center justify-center gap-2 rounded-full border border-[var(--border)] px-4 py-2 text-xs text-[var(--text-muted)] transition ${
-              canAddThread
-                ? "hover:border-[var(--border-strong)] hover:text-[var(--text-secondary)]"
-                : "opacity-60 cursor-not-allowed"
-            }`}
+            className={`flex items-center justify-center gap-2 rounded-full border border-[var(--border)] px-4 py-2 text-xs text-[var(--text-muted)] transition ${canAddThread
+              ? "hover:border-[var(--border-strong)] hover:text-[var(--text-secondary)]"
+              : "opacity-60 cursor-not-allowed"
+              }`}
             onClick={async () => {
               if (!canAddThread) return;
               await onAddThread(message);
@@ -927,9 +992,8 @@ function MessageCard({
           </button>
         ) : null}
         <button
-          className={`flex items-center gap-2 rounded-full border border-[var(--border)] px-4 py-2 text-xs text-[var(--text-muted)] transition hover:border-[var(--border-strong)] hover:text-[var(--text-secondary)] ${
-            isAssistant ? "" : "opacity-0 group-hover:opacity-100"
-          }`}
+          className={`flex items-center gap-2 rounded-full border border-[var(--border)] px-4 py-2 text-xs text-[var(--text-muted)] transition hover:border-[var(--border-strong)] hover:text-[var(--text-secondary)] ${isAssistant ? "" : "opacity-0 group-hover:opacity-100"
+            }`}
           onClick={async () => {
             await navigator.clipboard.writeText(messageTextContent);
             setCopied(true);
@@ -944,11 +1008,10 @@ function MessageCard({
         </button>
         {canEditThreads ? (
           <button
-            className={`flex items-center gap-2 rounded-full border px-4 py-2 text-xs transition ${
-              threadEditMode
-                ? "border-[var(--accent)] text-[var(--text-primary)]"
-                : "border-[var(--border)] text-[var(--text-muted)] hover:border-[var(--border-strong)] hover:text-[var(--text-secondary)]"
-            }`}
+            className={`flex items-center gap-2 rounded-full border px-4 py-2 text-xs transition ${threadEditMode
+              ? "border-[var(--accent)] text-[var(--text-primary)]"
+              : "border-[var(--border)] text-[var(--text-muted)] hover:border-[var(--border-strong)] hover:text-[var(--text-secondary)]"
+              }`}
             onClick={() => setThreadEditMode((prev) => !prev)}
             aria-label="Edit threads"
           >

package/template/src/lib/tooling/tools/files.ts

@@ -1,7 +1,7 @@
 import fs from "node:fs/promises";
 import nodeFs from "node:fs";
 import path from "node:path";
-import { assertAllowedPath, ensureMacOS } from "../safety";
+import { assertAllowedPath, ensureMacOS, normalizeAllowedRoots } from "../safety";
 import { runCommandSafe } from "../runtime";
 import type { ToolDefinition, ToolExecutionContext } from "../types";
 
@@ -10,6 +10,8 @@ type FileListInput = {
   recursive?: boolean;
   pattern?: string;
   limit?: number;
+  /** Only include files modified in the last N days (directories are always included so you can navigate). */
+  modifiedInLastDays?: number;
 };
 
 type FileWriteInput = {
@@ -20,6 +22,18 @@ type FileWriteInput = {
   recursive?: boolean;
 };
 
+type FileBatchMoveInput = {
+  operations: Array<{ source: string; destination: string }>;
+  overwrite?: boolean;
+};
+
+type FileFindInput = {
+  searchPath: string;
+  name: string;
+  type?: "file" | "directory" | "any";
+  maxDepth?: number;
+};
+
 const APPLESCRIPT_TIMEOUT_MS = 20_000;
 
 function asObject(input: unknown): Record<string, unknown> {
@@ -53,9 +67,14 @@ async function listDirectory(params: {
   recursive: boolean;
   pattern?: string;
   limit: number;
+  modifiedInLastDays?: number;
   signal?: AbortSignal;
 }) {
   const matcher = params.pattern ? wildcardToRegex(params.pattern) : null;
+  const modifiedCutoffMs =
+    typeof params.modifiedInLastDays === "number" && params.modifiedInLastDays > 0
+      ? Date.now() - params.modifiedInLastDays * 24 * 60 * 60 * 1000
+      : null;
   const output: Array<Record<string, unknown>> = [];
   const queue: string[] = [params.rootPath];
   let totalCount = 0;
@@ -66,7 +85,13 @@ async function listDirectory(params: {
     }
 
     const current = queue.shift() as string;
-    const entries = await fs.readdir(current, { withFileTypes: true });
+    let entries: nodeFs.Dirent[];
+    try {
+      entries = await fs.readdir(current, { withFileTypes: true });
+    } catch {
+      // Skip directories we can't read (permissions, broken symlinks, etc.)
+      continue;
+    }
 
     for (const entry of entries) {
       const fullPath = path.join(current, entry.name);
@@ -76,22 +101,74 @@ async function listDirectory(params: {
         }
       }
 
+      // Handle symlinks: check if they're valid before processing
+      if (entry.isSymbolicLink()) {
+        try {
+          // Use stat (follows symlinks) to check if the target exists
+          const targetStat = await fs.stat(fullPath);
+          // Process based on what the symlink points to
+          if (targetStat.isDirectory()) {
+            if (modifiedCutoffMs == null) {
+              totalCount += 1;
+              if (output.length < params.limit) {
+                output.push({ path: fullPath, name: entry.name, type: "directory" });
+              }
+            }
+            if (params.recursive || modifiedCutoffMs != null) {
+              queue.push(fullPath);
+            }
+          } else {
+            if (modifiedCutoffMs != null && targetStat.mtimeMs < modifiedCutoffMs) {
+              continue;
+            }
+            totalCount += 1;
+            if (output.length < params.limit) {
+              output.push({
+                path: fullPath,
+                name: entry.name,
+                type: "file",
+                size: targetStat.size,
+                modifiedAt: targetStat.mtimeMs,
+              });
+            }
+          }
+        } catch {
+          // Broken symlink - skip silently
+          continue;
+        }
+        continue;
+      }
+
       if (entry.isDirectory()) {
-        totalCount += 1;
-        if (output.length < params.limit) {
-          output.push({
-            path: fullPath,
-            name: entry.name,
-            type: "directory",
-          });
+        // When filtering by date, don't include directories in output (just traverse them)
+        // Otherwise, include them
+        if (modifiedCutoffMs == null) {
+          totalCount += 1;
+          if (output.length < params.limit) {
+            output.push({
+              path: fullPath,
+              name: entry.name,
+              type: "directory",
+            });
+          }
         }
-        if (params.recursive) {
+        // Recurse into directories when recursive OR when filtering by date (need to find recent files in subdirs)
+        if (params.recursive || modifiedCutoffMs != null) {
           queue.push(fullPath);
         }
         continue;
       }
 
-      const stat = await fs.stat(fullPath);
+      let stat: Awaited<ReturnType<typeof fs.stat>>;
+      try {
+        stat = await fs.stat(fullPath);
+      } catch {
+        // File disappeared or can't be accessed - skip
+        continue;
+      }
+      if (modifiedCutoffMs != null && stat.mtimeMs < modifiedCutoffMs) {
+        continue;
+      }
       totalCount += 1;
       if (output.length < params.limit) {
         output.push({
@@ -142,12 +219,17 @@ async function runFileList(input: unknown, context: ToolExecutionContext) {
     typeof payload.limit === "number" && Number.isFinite(payload.limit)
       ? Math.max(1, Math.min(1000, Math.floor(payload.limit)))
       : 200;
+  const modifiedInLastDays =
+    typeof payload.modifiedInLastDays === "number" && Number.isFinite(payload.modifiedInLastDays) && payload.modifiedInLastDays > 0
+      ? Math.min(365, Math.floor(payload.modifiedInLastDays))
+      : undefined;
 
   const { entries, totalCount } = await listDirectory({
     rootPath,
     recursive,
     pattern,
     limit,
+    modifiedInLastDays,
     signal: context.signal,
   });
 
@@ -155,6 +237,7 @@ async function runFileList(input: unknown, context: ToolExecutionContext) {
     rootPath,
     recursive,
     pattern,
+    modifiedInLastDays: modifiedInLastDays ?? undefined,
     count: totalCount,
     returnedCount: entries.length,
     limit,
@@ -297,34 +380,359 @@ async function runFileDeleteToTrash(input: unknown, context: ToolExecutionContex
   }
 
   ensureMacOS("Moving files to Trash");
-  const script =
+  // Create POSIX file reference outside Finder tell block to avoid "Can't get POSIX file" errors
+  const finderScript =
     'on run argv\n' +
     'set targetPath to item 1 of argv\n' +
-    'tell application "Finder"\n' +
-    'delete POSIX file targetPath\n' +
-    'end tell\n' +
+    'set theFile to POSIX file targetPath\n' +
+    'tell application "Finder" to delete theFile\n' +
     'return "ok"\n' +
     'end run';
 
-  await runAppleScript(script, [resolvedTarget], context.signal);
+  try {
+    await runAppleScript(finderScript, [resolvedTarget], context.signal);
+  } catch (finderErr) {
+    // Fallback: move to Trash via shell (reliable for empty folders and when Finder fails)
+    const moveErr = finderErr instanceof Error ? finderErr : new Error(String(finderErr));
+    if (!moveErr.message.includes("Can't get POSIX file") && !moveErr.message.includes("POSIX file")) {
+      throw finderErr;
+    }
+    const trashScript =
+      'on run argv\n' +
+      'set targetPath to item 1 of argv\n' +
+      'set trashPath to POSIX path of (path to trash)\n' +
+      'do shell script "mv " & quoted form of targetPath & " " & quoted form of trashPath\n' +
+      'return "ok"\n' +
+      'end run';
+    await runAppleScript(trashScript, [resolvedTarget], context.signal);
+  }
   return {
     trashed: true,
     path: resolvedTarget,
   };
 }
 
+async function runFileBatchMove(input: unknown, context: ToolExecutionContext) {
+  const payload = asObject(input) as FileBatchMoveInput;
+  const overwrite = asOptionalBoolean(payload.overwrite, false);
+
+  // Handle operations that might be stringified JSON
+  let operations = payload.operations;
+  if (typeof operations === "string") {
+    try {
+      operations = JSON.parse(operations) as Array<{ source: string; destination: string }>;
+    } catch {
+      throw new Error("Invalid operations: could not parse JSON array");
+    }
+  }
+
+  // Handle case where LLM sends the array at the top level
+  if (!operations && Array.isArray(input)) {
+    operations = input as Array<{ source: string; destination: string }>;
+  }
+
+  // Handle case where LLM sends with different key names
+  if (!operations) {
+    const payloadAny = payload as Record<string, unknown>;
+    const fallback = payloadAny.moves || payloadAny.files || payloadAny.items || payloadAny.list;
+    if (Array.isArray(fallback)) {
+      operations = fallback as Array<{ source: string; destination: string }>;
+    }
+  }
+
+  // Handle single move at top level: { source, destination } without operations array
+  if (!Array.isArray(operations) || operations.length === 0) {
+    const payloadAny = payload as Record<string, unknown>;
+    const src =
+      typeof payloadAny.source === "string" ? payloadAny.source.trim() :
+        typeof payloadAny.src === "string" ? payloadAny.src.trim() :
+          typeof payloadAny.from === "string" ? payloadAny.from.trim() : "";
+    const dest =
+      typeof payloadAny.destination === "string" ? payloadAny.destination.trim() :
+        typeof payloadAny.dest === "string" ? payloadAny.dest.trim() :
+          typeof payloadAny.to === "string" ? payloadAny.to.trim() : "";
+    if (src && dest) {
+      operations = [{ source: src, destination: dest }];
+    }
+  }
+
+  // Handle "move these files into this folder": { destination, sources } or { targetFolder, files } etc.
+  if (!Array.isArray(operations) || operations.length === 0) {
+    const payloadAny = payload as Record<string, unknown>;
+    const destDir =
+      typeof payloadAny.destination === "string" ? payloadAny.destination.trim() :
+        typeof payloadAny.dest === "string" ? payloadAny.dest.trim() :
+          typeof payloadAny.to === "string" ? payloadAny.to.trim() :
+            typeof payloadAny.targetFolder === "string" ? payloadAny.targetFolder.trim() : "";
+    const sourceListRaw =
+      payloadAny.sources ?? payloadAny.files ?? payloadAny.paths ?? payloadAny.sourcePaths ?? payloadAny.source;
+    const sourceList = Array.isArray(sourceListRaw)
+      ? sourceListRaw.map((s) => (typeof s === "string" ? s.trim() : "")).filter(Boolean)
+      : [];
+    if (destDir && sourceList.length > 0) {
+      operations = sourceList.map((sourcePath) => ({
+        source: sourcePath,
+        destination: path.join(destDir, path.basename(sourcePath)),
+      }));
+    }
+  }
+
+  if (!Array.isArray(operations) || operations.length === 0) {
+    const receivedKeys = Object.keys(payload).join(", ");
+    throw new Error(`Missing required array field: operations. Received keys: [${receivedKeys}]. Expected array of {source, destination} objects, or {destination, sources: [...]} to move many files into one folder.`);
+  }
+
+  // If operations is an array of path strings, treat as sources and use payload.destination as target folder
+  const firstOp = operations[0] as { source: string; destination: string } | string;
+  if (typeof firstOp === "string" && firstOp.trim()) {
+    const payloadAny = payload as Record<string, unknown>;
+    const destDir =
+      typeof payloadAny.destination === "string" ? payloadAny.destination.trim() :
+        typeof payloadAny.dest === "string" ? payloadAny.dest.trim() :
+          typeof payloadAny.to === "string" ? payloadAny.to.trim() :
+            typeof payloadAny.targetFolder === "string" ? payloadAny.targetFolder.trim() : "";
+    if (destDir) {
+      const pathStrings = operations as unknown as string[];
+      operations = pathStrings.map((p) => (typeof p === "string" ? p.trim() : "")).filter(Boolean).map((sourcePath) => ({
+        source: sourcePath,
+        destination: path.join(destDir, path.basename(sourcePath)),
+      }));
+    }
+  }
+
+  if (operations.length > 100) {
+    throw new Error("Too many operations (max 100)");
+  }
+
+  const results: Array<{ source: string; destination: string; moved: boolean; error?: string }> = [];
+
+  for (const op of operations) {
+    if (!op || typeof op !== "object") {
+      results.push({ source: "", destination: "", moved: false, error: "Invalid operation object" });
+      continue;
+    }
+
+    // Handle various possible field names
+    const opObj = op as Record<string, unknown>;
+    const source = typeof opObj.source === "string" ? opObj.source.trim() :
+      typeof opObj.src === "string" ? opObj.src.trim() :
+        typeof opObj.from === "string" ? opObj.from.trim() : "";
+    const destination = typeof opObj.destination === "string" ? opObj.destination.trim() :
+      typeof opObj.dest === "string" ? opObj.dest.trim() :
+        typeof opObj.to === "string" ? opObj.to.trim() : "";
+
+    if (!source || !destination) {
+      results.push({ source, destination, moved: false, error: "Missing source or destination path" });
+      continue;
+    }
+
+    try {
+      const resolvedSource = await assertAllowedPath({
+        candidate: source,
+        localTools: context.localTools,
+        mode: "read",
+      });
+      const resolvedDestination = await assertAllowedPath({
+        candidate: destination,
+        localTools: context.localTools,
+        mode: "write",
+      });
+
+      if (!overwrite) {
+        try {
+          await fs.access(resolvedDestination);
+          results.push({ source: resolvedSource, destination: resolvedDestination, moved: false, error: "Destination exists" });
+          continue;
+        } catch (err) {
+          if ((err as NodeJS.ErrnoException).code !== "ENOENT") {
+            throw err;
+          }
+        }
+      }
+
+      if (!context.localTools.dryRun) {
+        await fs.mkdir(path.dirname(resolvedDestination), { recursive: true });
+        await fs.rename(resolvedSource, resolvedDestination);
+      }
+
+      results.push({ source: resolvedSource, destination: resolvedDestination, moved: true });
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "Unknown error";
+      results.push({ source, destination, moved: false, error: message });
+    }
+  }
+
+  const movedCount = results.filter((r) => r.moved).length;
+  const failedCount = results.filter((r) => !r.moved).length;
+
+  return {
+    totalOperations: results.length,
+    movedCount,
+    failedCount,
+    dryRun: context.localTools.dryRun,
+    results,
+  };
+}
+
+function normalizeForSearch(input: string): string {
+  return input
+    .toLowerCase()
+    .replace(/[_\-\s]+/g, " ")
+    .replace(/[^a-z0-9\s]/g, "")
+    .trim();
+}
+
+/** Normalized name with no spaces (for ordered-word matching): e.g. "US_Debt_Clock" -> "usdebtclock" */
+function normalizedSlug(name: string): string {
+  return normalizeForSearch(name).replace(/\s+/g, "");
+}
+
+/** True if search words appear in order in the name (handles UsDebtClock, US_Debt_Clock, etc.). */
+function matchesOrderedWords(searchWords: string[], nameSlug: string): boolean {
+  if (searchWords.length === 0) return false;
+  let idx = 0;
+  for (const w of searchWords) {
+    const i = nameSlug.indexOf(w, idx);
+    if (i === -1) return false;
+    idx = i + w.length;
+  }
+  return true;
+}
+
+async function runFileFind(input: unknown, context: ToolExecutionContext) {
+  const payload = asObject(input) as FileFindInput;
+  const searchPath = asString(payload.searchPath, "searchPath");
+  const name = asString(payload.name, "name");
+  const targetType = payload.type ?? "any";
+  const maxDepth = typeof payload.maxDepth === "number" ? Math.max(1, Math.min(10, payload.maxDepth)) : 3;
+
+  const trimmedPath = searchPath.trim();
+  const searchAllRoots = trimmedPath === "~" || trimmedPath === "~/";
+
+  let resolvedSearchPath: string;
+  const queue: Array<{ dirPath: string; depth: number }> = [];
+
+  if (searchAllRoots) {
+    const roots = await normalizeAllowedRoots(context.localTools.allowedRoots);
+    if (roots.length === 0) {
+      throw new Error("No allowed filesystem roots are configured.");
+    }
+    resolvedSearchPath = roots[0];
+    for (const root of roots) {
+      queue.push({ dirPath: root, depth: 0 });
+    }
+  } else {
+    resolvedSearchPath = await assertAllowedPath({
+      candidate: searchPath,
+      localTools: context.localTools,
+      mode: "read",
+    });
+    queue.push({ dirPath: resolvedSearchPath, depth: 0 });
+  }
+
+  const normalizedSearch = normalizeForSearch(name);
+  const matches: Array<{ path: string; name: string; type: string; matchScore: number }> = [];
+
+  while (queue.length > 0 && matches.length < 20) {
+    if (context.signal?.aborted) {
+      throw new Error("Aborted.");
+    }
+
+    const current = queue.shift()!;
+    if (current.depth >= maxDepth) {
+      continue;
+    }
+
+    try {
+      const entries = await fs.readdir(current.dirPath, { withFileTypes: true });
+
+      for (const entry of entries) {
+        const fullPath = path.join(current.dirPath, entry.name);
+        const isDir = entry.isDirectory();
+        const entryType = isDir ? "directory" : "file";
+
+        if (targetType !== "any" && targetType !== entryType) {
+          if (isDir) {
+            queue.push({ dirPath: fullPath, depth: current.depth + 1 });
+          }
+          continue;
+        }
+
+        const normalizedName = normalizeForSearch(entry.name);
+        const nameSlug = normalizedSlug(entry.name);
+        const searchWords = normalizedSearch.split(" ").filter(Boolean);
+        let matchScore = 0;
+
+        // Exact match (normalized): "us debt clock" === "us debt clock"
+        if (normalizedName === normalizedSearch) {
+          matchScore = 100;
+        }
+        // Same with no spaces: "usdebtclock" vs "usdebtclock" (e.g. UsDebtClock)
+        else if (nameSlug === normalizedSearch.replace(/\s+/g, "")) {
+          matchScore = 95;
+        }
+        // Starts with search term
+        else if (normalizedName.startsWith(normalizedSearch)) {
+          matchScore = 80;
+        }
+        // Contains search term (full phrase)
+        else if (normalizedName.includes(normalizedSearch)) {
+          matchScore = 60;
+        }
+        // Ordered words in name (handles US_Debt_Clock, UsDebtClock, us-debt-clock, etc.)
+        else if (matchesOrderedWords(searchWords, nameSlug)) {
+          matchScore = 70;
+        }
+        // Words overlap significantly
+        else if (searchWords.length > 0) {
+          const nameWords = normalizedName.split(" ").filter(Boolean);
+          const matchedWords = searchWords.filter((w) => nameWords.some((nw) => nw.includes(w) || w.includes(nw)));
+          if (matchedWords.length > 0) {
+            matchScore = Math.min(50, (matchedWords.length / searchWords.length) * 50);
+          }
+        }
+
+        if (matchScore > 0) {
+          matches.push({
+            path: fullPath,
+            name: entry.name,
+            type: entryType,
+            matchScore,
+          });
+        }
+
+        if (isDir) {
+          queue.push({ dirPath: fullPath, depth: current.depth + 1 });
+        }
+      }
+    } catch {
+      // Skip directories we can't read
+    }
+  }
+
+  matches.sort((a, b) => b.matchScore - a.matchScore);
+
+  return {
+    searchPath: resolvedSearchPath,
+    searchName: name,
+    matches: matches.slice(0, 10),
+    totalFound: matches.length,
+  };
+}
+
 export const fileTools: ToolDefinition[] = [
   {
     name: "file_list",
-    description: "List files/folders under an allowed path. Supports optional recursion and wildcard name pattern.",
+    description: "List files and folders at a given path. Use to explore directory contents, find files by pattern, or see what's inside a folder before organizing. Supports recursive listing with optional wildcard (e.g. pattern: '*.pdf') and optional time filter: use modifiedInLastDays (e.g. 7 for 'last 7 days') to only include files modified within that period—directories are always included so you can navigate.",
     inputSchema: {
       type: "object",
       required: ["path"],
       properties: {
-        path: { type: "string" },
-        recursive: { type: "boolean" },
-        pattern: { type: "string" },
-        limit: { type: "number" },
+        path: { type: "string", description: "Directory path to list" },
+        recursive: { type: "boolean", description: "If true, list all nested subdirectories" },
+        pattern: { type: "string", description: "Wildcard pattern to filter results (e.g. '*.txt', '*.icns')" },
+        limit: { type: "number", description: "Maximum number of entries to return (default 200)" },
+        modifiedInLastDays: { type: "number", description: "If set, only include files modified in the last N days (e.g. 7 for last week). Directories are always included." },
       },
       additionalProperties: false,
     },
@@ -333,14 +741,14 @@ export const fileTools: ToolDefinition[] = [
   },
   {
     name: "file_move",
-    description: "Move a file/folder from source to destination.",
+    description: "Move or rename a file or folder. Use to reorganize files into different folders, rename items, or relocate content. Parent directories are created automatically if they don't exist.",
     inputSchema: {
       type: "object",
       required: ["source", "destination"],
       properties: {
-        source: { type: "string" },
-        destination: { type: "string" },
-        overwrite: { type: "boolean" },
+        source: { type: "string", description: "Current path of the file/folder to move" },
+        destination: { type: "string", description: "New path (including new name if renaming)" },
+        overwrite: { type: "boolean", description: "If true, overwrite existing file at destination" },
       },
       additionalProperties: false,
     },
@@ -349,14 +757,14 @@ export const fileTools: ToolDefinition[] = [
   },
   {
     name: "file_copy",
-    description: "Copy a file from source to destination.",
+    description: "Copy a file to another location. Use to duplicate files, create backups, or copy files into new folders. Parent directories are created automatically.",
     inputSchema: {
       type: "object",
       required: ["source", "destination"],
       properties: {
-        source: { type: "string" },
-        destination: { type: "string" },
-        overwrite: { type: "boolean" },
+        source: { type: "string", description: "Path of the file to copy" },
+        destination: { type: "string", description: "Path where the copy should be created" },
+        overwrite: { type: "boolean", description: "If true, overwrite existing file at destination" },
       },
       additionalProperties: false,
     },
@@ -365,13 +773,13 @@ export const fileTools: ToolDefinition[] = [
   },
   {
     name: "file_mkdir",
-    description: "Create a folder path.",
+    description: "Create a new folder or nested folder structure. Use to set up directory organization, create subfolders for categorizing files, or prepare folders before moving files into them. By default creates all parent directories if they don't exist.",
     inputSchema: {
       type: "object",
       required: ["path"],
       properties: {
-        path: { type: "string" },
-        recursive: { type: "boolean" },
+        path: { type: "string", description: "Path of the folder to create (e.g. '/Users/me/Documents/Projects/2024')" },
+        recursive: { type: "boolean", description: "If true (default), create parent directories as needed" },
       },
       additionalProperties: false,
     },
@@ -380,16 +788,60 @@ export const fileTools: ToolDefinition[] = [
   },
   {
     name: "file_delete_to_trash",
-    description: "Move a file/folder to Trash (macOS).",
+    description: "Move a file or folder to Trash (safe delete on macOS). Items can be recovered from Trash if needed.",
     inputSchema: {
       type: "object",
       required: ["path"],
       properties: {
-        path: { type: "string" },
+        path: { type: "string", description: "Path of the file or folder to move to Trash" },
       },
       additionalProperties: false,
     },
     risk: "destructive",
     execute: runFileDeleteToTrash,
   },
+  {
+    name: "file_batch_move",
+    description: "Move multiple files in a single operation. Use when moving many files into one folder: pass { destination: \"<folder path>\", sources: [\"<path1>\", \"<path2>\", ...] }—each file is moved into that folder keeping its name. Or pass { operations: [ { source, destination }, ... ] } for full control. Prefer one call over many file_move calls.",
+    inputSchema: {
+      type: "object",
+      required: [],
+      properties: {
+        operations: {
+          type: "array",
+          description: "Array of { source, destination } for each move; or array of source paths if destination is also provided",
+          items: {
+            type: "object",
+            properties: {
+              source: { type: "string", description: "Current path of the file" },
+              destination: { type: "string", description: "New path for the file" },
+            },
+          },
+        },
+        destination: { type: "string", description: "When moving many files into one folder, target folder path (use with sources or operations as path list)" },
+        sources: { type: "array", items: { type: "string" }, description: "Paths of files to move into destination (each keeps its filename)" },
+        overwrite: { type: "boolean", description: "If true, overwrite existing files at destinations" },
+      },
+      additionalProperties: true,
+    },
+    risk: "write",
+    execute: runFileBatchMove,
+  },
+  {
+    name: "file_find",
+    description: "Find files or folders by name with fuzzy matching. Handles case, underscores, hyphens, spaces, and numbers (e.g. 'us debt clock' finds 'US_Debt_Clock', 'UsDebtClock'). Use when the user gives a name that might not match exactly. Prefer searchPath '~' to search all allowed roots when the location is unknown.",
+    inputSchema: {
+      type: "object",
+      required: ["searchPath", "name"],
+      properties: {
+        searchPath: { type: "string", description: "Directory to search within (e.g. ~/Downloads). Use '~' to search all allowed roots (Desktop, Documents, Downloads, etc.) in one call." },
+        name: { type: "string", description: "Name to search for (fuzzy matching: case, underscores, spaces ignored)" },
+        type: { type: "string", enum: ["file", "directory", "any"], description: "Filter by type (default: any)" },
+        maxDepth: { type: "number", description: "How deep to search in subdirectories (default: 3, max: 10)" },
+      },
+      additionalProperties: false,
+    },
+    risk: "read",
+    execute: runFileFind,
+  },
 ];

package/template/src/lib/tooling/tools/schedule.ts

@@ -8,6 +8,8 @@ type CalendarCreateInput = {
   end?: string;
   location?: string;
   notes?: string;
+  /** Calendar name to create the event on (e.g. "Personal", "Work"). If omitted, uses default calendar. */
+  calendar?: string;
 };
 
 type CalendarListInput = {
@@ -606,6 +608,7 @@ async function runCalendarCreateEvent(input: unknown, context: ToolExecutionCont
   const end = endInput || start;
   const location = typeof payload.location === "string" ? payload.location.trim() : "";
   const notes = typeof payload.notes === "string" ? payload.notes.trim() : "";
+  const calendarName = typeof payload.calendar === "string" && payload.calendar.trim() ? payload.calendar.trim() : "";
   const startParts = parseDateTimeParts(start, { defaultHour: 9, defaultMinute: 0 });
   if (!startParts) {
     throw new Error(`Invalid start date/time: ${start}`);
@@ -631,6 +634,7 @@ async function runCalendarCreateEvent(input: unknown, context: ToolExecutionCont
       endParts,
       location,
       notes,
+      calendar: calendarName || null,
     };
   }
 
@@ -649,11 +653,27 @@ async function runCalendarCreateEvent(input: unknown, context: ToolExecutionCont
     'set endMinute to (item 11 of argv) as integer\n' +
     'set eventLocation to item 12 of argv\n' +
     'set eventNotes to item 13 of argv\n' +
+    'set requestedCalendar to item 14 of argv\n' +
     'tell application "Calendar"\n' +
     'set targetCalendar to missing value\n' +
+    // First try the requested calendar name (case-insensitive)
+    'if requestedCalendar is not "" then\n' +
+    'repeat with cal in calendars\n' +
+    'ignoring case\n' +
+    'if (name of cal as text) is equal to requestedCalendar then\n' +
+    'set targetCalendar to cal\n' +
+    'exit repeat\n' +
+    'end if\n' +
+    'end ignoring\n' +
+    'end repeat\n' +
+    'end if\n' +
+    // Fallback: try "Home" calendar if no calendar specified
+    'if targetCalendar is missing value and requestedCalendar is "" then\n' +
     'try\n' +
     'set targetCalendar to calendar "Home"\n' +
     'end try\n' +
+    'end if\n' +
+    // Last fallback: first available calendar
     'if targetCalendar is missing value then\n' +
     'try\n' +
     'set targetCalendar to first calendar\n' +
@@ -673,9 +693,9 @@ async function runCalendarCreateEvent(input: unknown, context: ToolExecutionCont
     'tell targetCalendar\n' +
     'set createdEvent to make new event with properties {summary:eventTitle, start date:startDate, end date:endDate, location:eventLocation, description:eventNotes}\n' +
     "end tell\n" +
-    'set calendarName to (name of targetCalendar as text)\n' +
+    'set calendarUsed to (name of targetCalendar as text)\n' +
     "end tell\n" +
-    'return "created" & tab & calendarName\n' +
+    'return "created" & tab & calendarUsed\n' +
     "end run";
   const output = await runAppleScript(
     script,
@@ -693,10 +713,11 @@ async function runCalendarCreateEvent(input: unknown, context: ToolExecutionCont
       String(endParts.minute),
       location,
       notes,
+      calendarName,
     ],
     context.signal,
   );
-  const [, calendarName] = output.split("\t");
+  const [, calendarUsed] = output.split("\t");
   return {
     created: true,
     title,
@@ -712,7 +733,7 @@ async function runCalendarCreateEvent(input: unknown, context: ToolExecutionCont
     ).padStart(2, "0")}T${String(endParts.hour).padStart(2, "0")}:${String(
       endParts.minute,
     ).padStart(2, "0")}:00`,
-    calendar: calendarName?.trim() || null,
+    calendar: calendarUsed?.trim() || null,
     location,
   };
 }
@@ -1244,7 +1265,7 @@ export const scheduleTools: ToolDefinition[] = [
   },
   {
     name: "calendar_create_event",
-    description: "Create a Calendar event. Use explicit dates/times (e.g. YYYY-MM-DD or 'Friday at 2pm') so the event is created on the correct day.",
+    description: "Create a Calendar event. Use explicit dates/times (e.g. YYYY-MM-DD or 'Friday at 2pm') so the event is created on the correct day. Specify calendar name (e.g. 'Personal', 'Work') to target a specific calendar.",
     inputSchema: {
       type: "object",
       required: ["title", "start"],
@@ -1254,6 +1275,7 @@ export const scheduleTools: ToolDefinition[] = [
         end: { type: "string" },
         location: { type: "string" },
         notes: { type: "string" },
+        calendar: { type: "string", description: "Calendar name (e.g. 'Personal', 'Work'). Case-insensitive. If omitted, defaults to Home or first calendar." },
       },
       additionalProperties: false,
     },