@soederpop/luca 0.0.5 → 0.0.7

package/src/introspection/generated.web.ts

@@ -1,7 +1,7 @@
 import { setBuildTimeData, setContainerBuildTimeData } from './index.js';
 
 // Auto-generated introspection registry data
-// Generated at: 2026-03-12T02:48:58.250Z
+// Generated at: 2026-03-19T00:28:05.997Z
 
 setBuildTimeData('features.containerLink', {
   "id": "features.containerLink",

package/src/introspection/index.ts

@@ -161,12 +161,38 @@ export function getContainerBuildTimeData(className: string): Partial<ContainerI
 export function setBuildTimeData(key: string, data: HelperIntrospection) {
 	const existing = __INTROSPECTION__.get(key)
 
+	// Merge events: build-time AST provides descriptions, runtime Zod schemas provide arguments.
+	// For each event, preserve runtime arguments if the build-time entry has none.
+	const mergedEvents: Record<string, any> = { ...(data.events || {}) }
+	if (existing?.events) {
+		for (const [eventName, existingEvent] of Object.entries(existing.events)) {
+			if (mergedEvents[eventName]) {
+				// Build-time entry exists — merge in runtime arguments and description if build-time has none
+				const buildArgs = mergedEvents[eventName].arguments || {}
+				const runtimeArgs = (existingEvent as any).arguments || {}
+				const buildDesc = mergedEvents[eventName].description || ''
+				const runtimeDesc = (existingEvent as any).description || ''
+				const isGenericDesc = buildDesc.startsWith('Event emitted by ')
+				if (Object.keys(buildArgs).length === 0 && Object.keys(runtimeArgs).length > 0) {
+					mergedEvents[eventName] = { ...mergedEvents[eventName], arguments: runtimeArgs }
+				}
+				if (isGenericDesc && runtimeDesc) {
+					mergedEvents[eventName] = { ...mergedEvents[eventName], description: runtimeDesc }
+				}
+			} else {
+				// Event only exists in runtime (from Zod schema) — preserve it
+				mergedEvents[eventName] = existingEvent
+			}
+		}
+	}
+
 	__INTROSPECTION__.set(key, {
 		...data,
 		// preserve runtime-derived className/state/options if registration already happened
 		className: data.className || existing?.className,
 		state: existing?.state || data.state || {},
 		options: existing?.options || data.options || {},
+		events: mergedEvents,
 		getters: data.getters || existing?.getters || {},
 		envVars: existing?.envVars || data.envVars || [],
 		examples: data.examples || existing?.examples,

package/src/node/container.ts

@@ -6,12 +6,16 @@ import type { FeatureOptions } from "./feature";
 import { features, Feature } from "./feature";
 import type { AvailableFeatures } from "../feature";
 import { Client, type ClientsInterface } from "../client";
+import "../clients/rest";
+import "../clients/graph";
+import "../clients/websocket";
 import { Server, type ServersInterface } from "../server";
 import "../servers/express";
 import "../servers/socket";
 import "../servers/mcp";
 import { Command, type CommandsInterface } from "../command";
 import { Endpoint, type EndpointsInterface } from "../endpoint";
+import { Selector, type SelectorsInterface } from "../selector";
 
 import minimist from "minimist";
 import { omit, kebabCase, camelCase, mapKeys, castArray } from "lodash-es";
@@ -53,7 +57,6 @@ import "./features/google-sheets";
 import "./features/google-calendar";
 import "./features/google-docs";
 import "./features/window-manager";
-import "./features/launcher-app-command-listener";
 import "./features/nlp";
 import "./features/process-manager"
 import "./features/tts";
@@ -98,7 +101,6 @@ import type { GoogleSheets } from './features/google-sheets';
 import type { GoogleCalendar } from './features/google-calendar';
 import type { GoogleDocs } from './features/google-docs';
 import type { WindowManager } from './features/window-manager';
-import type { LauncherAppCommandListener } from './features/launcher-app-command-listener';
 import type { NLP } from './features/nlp';
 import type { ProcessManager } from './features/process-manager'
 import type { TTS } from './features/tts';
@@ -138,7 +140,6 @@ export {
   type GoogleCalendar,
   type GoogleDocs,
   type WindowManager,
-  type LauncherAppCommandListener,
   type NLP,
   type ProcessManager,
   type TTS,
@@ -204,7 +205,6 @@ export interface NodeFeatures extends AvailableFeatures {
   googleCalendar: typeof GoogleCalendar;
   googleDocs: typeof GoogleDocs;
   windowManager: typeof WindowManager;
-  launcherAppCommandListener: typeof LauncherAppCommandListener;
   nlp: typeof NLP;
   processManager: typeof ProcessManager;
   tts: typeof TTS;
@@ -214,7 +214,7 @@ export interface NodeFeatures extends AvailableFeatures {
   dns: typeof Dns;
 }
 
-export type ClientsAndServersInterface = ClientsInterface & ServersInterface & CommandsInterface & EndpointsInterface;
+export type ClientsAndServersInterface = ClientsInterface & ServersInterface & CommandsInterface & EndpointsInterface & SelectorsInterface;
 
 export interface NodeContainer extends ClientsAndServersInterface {}
 
@@ -253,7 +253,6 @@ export class NodeContainer<
   googleCalendar?: GoogleCalendar;
   googleDocs?: GoogleDocs;
   windowManager?: WindowManager;
-  launcherAppCommandListener?: LauncherAppCommandListener;
   nlp?: NLP;
   processManager?: ProcessManager;
   tts?: TTS;
@@ -286,7 +285,7 @@ export class NodeContainer<
       }
     });
 
-    this.use(Client).use(Server).use(Command).use(Endpoint);
+    this.use(Client).use(Server).use(Command).use(Endpoint).use(Selector);
   }
 
   override get Feature() {

package/src/node/features/content-db.ts

@@ -1,7 +1,8 @@
 import { Feature } from '../feature.js'
+import * as contentbaseExports from 'contentbase'
 import { parse, Collection, extractSections, type ModelDefinition } from 'contentbase'
 import { z } from 'zod'
-import { FeatureStateSchema, FeatureOptionsSchema } from '../../schemas/base.js'
+import { FeatureStateSchema, FeatureOptionsSchema, FeatureEventsSchema } from '../../schemas/base.js'
 import { join, dirname } from 'node:path'
 import { existsSync, readdirSync } from 'node:fs'
 
@@ -18,6 +19,10 @@ export const ContentDbOptionsSchema = FeatureOptionsSchema.extend({
 export type ContentDbState = z.infer<typeof ContentDbStateSchema>
 export type ContentDbOptions = z.infer<typeof ContentDbOptionsSchema>
 
+export const ContentDbEventsSchema = FeatureEventsSchema.extend({
+  reloaded: z.tuple([]).describe('When the content collection is reloaded from disk'),
+}).describe('ContentDb events')
+
 /**
  * Provides access to a Contentbase Collection for a folder of structured markdown files.
  *
@@ -37,6 +42,7 @@ export class ContentDb extends Feature<ContentDbState, ContentDbOptions> {
   static override shortcut = 'features.contentDb' as const
   static override stateSchema = ContentDbStateSchema
   static override optionsSchema = ContentDbOptionsSchema
+  static override eventsSchema = ContentDbEventsSchema
   static { Feature.register(this, 'contentDb') }
 
   override get initialState(): ContentDbState {
@@ -52,11 +58,52 @@ export class ContentDb extends Feature<ContentDbState, ContentDbOptions> {
   }
 
   _collection?: Collection
+  private _contentbaseSeeded = false
 
   /** Returns the lazily-initialized Collection instance for the configured rootPath. */
   get collection() {
     if (this._collection) return this._collection
-    return this._collection = new Collection({ rootPath: this.options.rootPath })
+
+    const opts: any = { rootPath: this.options.rootPath }
+
+    // When contentbase isn't in node_modules (e.g. compiled luca binary),
+    // provide a VM-based module loader so models.ts can resolve its imports
+    if (!this._canNativeImportContentbase()) {
+      opts.moduleLoader = (filePath: string) => {
+        this._seedContentbaseVirtualModules()
+        const vm = this.container.feature('vm') as any
+        return vm.loadModule(filePath)
+      }
+    }
+
+    return this._collection = new Collection(opts)
+  }
+
+  /** Check if contentbase is resolvable via native import from the project root */
+  private _canNativeImportContentbase(): boolean {
+    const cwd = this.container.cwd
+    return existsSync(join(cwd, 'node_modules', 'contentbase'))
+  }
+
+  /** Seed the VM with virtual modules so models.ts can import from 'contentbase', 'zod', etc. */
+  private _seedContentbaseVirtualModules(): void {
+    if (this._contentbaseSeeded) return
+    this._contentbaseSeeded = true
+
+    const vm = this.container.feature('vm') as any
+
+    // Seed luca modules first (helpers does this for @soederpop/luca)
+    const helpers = this.container.feature('helpers') as any
+    if (helpers?.seedVirtualModules) {
+      helpers.seedVirtualModules()
+    }
+
+    // Register contentbase barrel — everything the library exports
+    vm.defineModule('contentbase', contentbaseExports)
+
+    // Common deps that models.ts files tend to use
+    try { vm.defineModule('js-yaml', require('js-yaml')) } catch {}
+    try { vm.defineModule('mdast-util-to-string', require('mdast-util-to-string')) } catch {}
   }
 
   /** Returns the absolute resolved path to the collection root directory. */

package/src/node/features/disk-cache.ts

@@ -36,15 +36,17 @@ export class DiskCache extends Feature<FeatureState,DiskCacheOptions> {
   static override optionsSchema = DiskCacheOptionsSchema
   static { Feature.register(this, 'diskCache') }
 
-  constructor(options: DiskCacheOptions, context: ContainerContext) {
-    super(options, context)
-    this._cache = this.create() 
-    this.hide('_cache')
-  }
-  
   /** Returns the underlying cacache instance configured with the cache directory path. */
   get cache() {
-    return this._cache
+    if(this._cache) { 
+	    return this._cache
+    }
+
+    const cache = this.create()
+
+    Object.defineProperty(this, '_cache', { value: cache, enumerable: false })
+
+    return cache
   }
   
   /**
@@ -328,7 +330,7 @@ export class DiskCache extends Feature<FeatureState,DiskCacheOptions> {
  
   /**
    * Create a cacache instance with the specified path
-   * @param path - Optional cache directory path (defaults to options.path or node_modules/.cache/luca-disk-cache)
+   * @param path - Optional cache directory path (defaults to options.path or ~/.cache/luca/disk-cache-{cwdHash})
    * @returns Configured cacache instance with all methods bound to the path
    * @example
    * ```typescript
@@ -336,7 +338,12 @@ export class DiskCache extends Feature<FeatureState,DiskCacheOptions> {
    * ```
    */
   create(path?: string) {
-    path = path || this.options.path || this.container.paths.resolve('node_modules', '.cache', 'luca-disk-cache')
+    if (!path && !this.options.path) {
+      const cwdHash = this.container.utils.hashObject(this.container.cwd)
+      path = this.container.paths.resolve(process.env.HOME!, '.cache', 'luca', `disk-cache-${cwdHash}`)
+    } else {
+      path = path || this.options.path!
+    }
     this.container.fs.ensureFolder(path)
     const arg = (fn: (...args: any) => any) => partial(fn, path);
 

package/src/node/features/dns.ts

@@ -131,10 +131,23 @@ export class Dns extends Feature<DnsState, DnsOptions> {
     }
   }
 
+  private _resolvedDigPath: string | null = null
+
   get proc() {
     return this.container.feature('proc')
   }
 
+  /** Resolved path to the dig binary */
+  get digPath(): string {
+    if (this._resolvedDigPath) return this._resolvedDigPath
+    try {
+      this._resolvedDigPath = this.proc.exec('which dig').trim()
+    } catch {
+      this._resolvedDigPath = 'dig'
+    }
+    return this._resolvedDigPath
+  }
+
   /**
    * Checks whether the `dig` binary is available on the system.
    *
@@ -148,7 +161,7 @@ export class Dns extends Feature<DnsState, DnsOptions> {
    * ```
    */
   async isAvailable(): Promise<boolean> {
-    const result = await this.proc.spawnAndCapture('dig', ['-v'])
+    const result = await this.proc.spawnAndCapture(this.digPath, ['-v'])
     // dig -v prints version to stderr and exits 0
     return result.exitCode === 0
   }
@@ -180,7 +193,7 @@ export class Dns extends Feature<DnsState, DnsOptions> {
    */
   async resolve(domain: string, type: DnsRecordType, options: QueryOptions = {}): Promise<DnsQueryResult> {
     const args = this.buildDigArgs(domain, type, options)
-    const result = await this.proc.spawnAndCapture('dig', args)
+    const result = await this.proc.spawnAndCapture(this.digPath, args)
 
     if (result.exitCode !== 0) {
       throw new Error(`dig query failed: ${result.stderr || 'unknown error'}`)
@@ -446,7 +459,7 @@ export class Dns extends Feature<DnsState, DnsOptions> {
     }
     args.unshift('-x', ip)
 
-    const result = await this.proc.spawnAndCapture('dig', args)
+    const result = await this.proc.spawnAndCapture(this.digPath, args)
 
     if (result.exitCode !== 0) {
       throw new Error(`dig reverse lookup failed: ${result.stderr || 'unknown error'}`)

package/src/node/features/docker.ts

@@ -101,10 +101,24 @@ export class Docker extends Feature<DockerState, DockerOptions> {
   /**
    * Get the proc feature for executing shell commands
    */
+  private _resolvedDockerPath: string | null = null
+
   get proc() {
     return this.container.feature('proc')
   }
 
+  /** Resolve the docker binary path via `which`, caching the result. Options take precedence. */
+  get dockerPath(): string {
+    if (this.options.dockerPath) return this.options.dockerPath
+    if (this._resolvedDockerPath) return this._resolvedDockerPath
+    try {
+      this._resolvedDockerPath = this.proc.exec('which docker').trim()
+    } catch {
+      this._resolvedDockerPath = 'docker'
+    }
+    return this._resolvedDockerPath
+  }
+
   /**
    * Check if Docker is available and working.
    *
@@ -117,8 +131,7 @@ export class Docker extends Feature<DockerState, DockerOptions> {
    */
   async checkDockerAvailability(): Promise<boolean> {
     try {
-      const dockerPath = this.options.dockerPath || 'docker'
-      const result = await this.proc.spawnAndCapture(dockerPath, ['--version'])
+      const result = await this.proc.spawnAndCapture(this.dockerPath, ['--version'])
       
       if (result.exitCode === 0) {
         this.setState({ isDockerAvailable: true, lastError: undefined })
@@ -152,8 +165,7 @@ export class Docker extends Feature<DockerState, DockerOptions> {
     }
 
     try {
-      const dockerPath = this.options.dockerPath || 'docker'
-      const result = await this.proc.spawnAndCapture(dockerPath, args)
+      const result = await this.proc.spawnAndCapture(this.dockerPath, args)
       
       if (result.exitCode !== 0) {
         this.setState({ lastError: result.stderr })

package/src/node/features/esbuild.ts

@@ -54,6 +54,26 @@ export class ESBuild extends Feature {
       ...options
     })
   }
+
+  /**
+   * Bundle one or more entry points, resolving imports and requires into a single output.
+   * Supports Node platform by default so require() and Node builtins are handled.
+   * Returns in-memory output files unless write is enabled in options.
+   * @param entryPoints - File paths to bundle from
+   * @param options - esbuild BuildOptions overrides
+   * @returns The build result with outputFiles when write is false
+   */
+  async bundle(entryPoints: string[], options?: esbuild.BuildOptions) {
+    return esbuild.build({
+      entryPoints,
+      bundle: true,
+      platform: 'node',
+      format: 'esm',
+      target: 'es2020',
+      write: false,
+      ...options
+    })
+  }
 }
 
 export default ESBuild

package/src/node/features/file-manager.ts

@@ -1,9 +1,9 @@
 import { z } from 'zod'
-import { FeatureStateSchema, FeatureOptionsSchema } from '../../schemas/base.js'
+import { FeatureEventsSchema, FeatureStateSchema, FeatureOptionsSchema } from '../../schemas/base.js'
 import { State } from "../../state.js";
 import { Feature } from "../feature.js";
-import { parse, relative } from "path";
-import { statSync } from "fs";
+import { parse, relative, join as pathJoin } from "path";
+import { statSync, readFileSync, existsSync } from "fs";
 import micromatch from "micromatch";
 import { castArray } from "lodash-es";
 import chokidar from "chokidar";
@@ -37,6 +37,15 @@ export const FileManagerOptionsSchema = FeatureOptionsSchema.extend({
   exclude: z.union([z.string(), z.array(z.string())]).optional().describe('Glob patterns to exclude from file scanning'),
 })
 
+export const FileManagerEventsSchema = FeatureEventsSchema.extend({
+  'file:change': z.tuple([
+    z.object({
+      type: z.enum(['add', 'change', 'delete']).describe('The type of file change'),
+      path: z.string().describe('Absolute path to the changed file'),
+    }).describe('File change event payload'),
+  ]).describe('Emitted when a watched file is added, changed, or deleted'),
+}).describe('FileManager events')
+
 export type FileManagerState = z.infer<typeof FileManagerStateSchema>
 export type FileManagerOptions = z.infer<typeof FileManagerOptionsSchema>
 
@@ -61,6 +70,7 @@ export class FileManager<
   static override shortcut = 'features.fileManager' as const
   static override stateSchema = FileManagerStateSchema
   static override optionsSchema = FileManagerOptionsSchema
+  static override eventsSchema = FileManagerEventsSchema
   static { Feature.register(this, 'fileManager') }
   
   files: State<Record<string, File>> = new State<Record<string, File>>({
@@ -135,6 +145,11 @@ export class FileManager<
     return !!this.state.get("watching");
   }
 
+  /** Returns the list of directories currently being watched. */
+  get watchedPaths(): string[] {
+    return this.state.get("watchedPaths") || [];
+  }
+
   /** 
    * Starts the file manager and scans the files in the project.
    * @param {object} [options={}] - Options for the file manager
@@ -154,7 +169,11 @@ export class FileManager<
     }
 
     try {
-      await this.scanFiles(options);
+      const loaded = await this.loadFromCache();
+      if (!loaded) {
+        await this.scanFiles(options);
+        await this.writeToCache();
+      }
     } catch (error) {
       console.error(error);
       this.state.set("failed", true);
@@ -166,6 +185,117 @@ export class FileManager<
     return this;
   }
 
+  /**
+   * Attempts to load the file index from disk cache.
+   * Only uses cache when in a clean git repo (sha hasn't changed, no dirty files).
+   * @returns true if cache was loaded successfully, false otherwise
+   */
+  /**
+   * Reads the current git SHA by reading .git/HEAD directly,
+   * avoiding the ~19ms cost of shelling out to `git rev-parse HEAD`.
+   */
+  private readGitShaFast(): string | null {
+    try {
+      const { git } = this.container;
+      if (!git.isRepo) return null;
+
+      const gitDir = pathJoin(git.repoRoot, '.git');
+      const head = readFileSync(pathJoin(gitDir, 'HEAD'), 'utf8').trim();
+
+      // Detached HEAD — already a sha
+      if (!head.startsWith('ref: ')) return head;
+
+      // Resolve the ref
+      const refPath = pathJoin(gitDir, head.slice(5));
+      if (existsSync(refPath)) {
+        return readFileSync(refPath, 'utf8').trim();
+      }
+
+      // Packed refs fallback
+      const packedRefsPath = pathJoin(gitDir, 'packed-refs');
+      if (existsSync(packedRefsPath)) {
+        const ref = head.slice(5);
+        const packed = readFileSync(packedRefsPath, 'utf8');
+        const match = packed.match(new RegExp(`^([0-9a-f]{40}) ${ref}`, 'm'));
+        if (match) return match[1];
+      }
+
+      return null;
+    } catch {
+      return null;
+    }
+  }
+
+  private async loadFromCache(): Promise<boolean> {
+    try {
+      const sha = this.readGitShaFast();
+      if (!sha) return false;
+
+      const cache = this.container.feature('diskCache') as any;
+      const cacheKey = `file-index:${sha}`;
+
+      if (!(await cache.has(cacheKey))) return false;
+
+      const cached = await cache.get(cacheKey, true) as { dirs: Record<string, number>, files: Record<string, any> };
+      if (!cached?.files || !cached?.dirs) return false;
+
+      // Check if any directory mtime has changed — catches new/deleted/renamed files
+      for (const [dir, cachedMtimeMs] of Object.entries(cached.dirs)) {
+        try {
+          const current = statSync(dir).mtimeMs;
+          if (current !== cachedMtimeMs) return false;
+        } catch {
+          // Directory no longer exists
+          return false;
+        }
+      }
+
+      for (const [relativePath, file] of Object.entries(cached.files)) {
+        this.files.set(relativePath, {
+          ...file as File,
+          modifiedAt: new Date((file as any).modifiedAt),
+          createdAt: new Date((file as any).createdAt),
+        });
+      }
+
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * Writes the current file index to disk cache, keyed by git sha.
+   * Stores directory mtimes alongside file data so the cache can be
+   * invalidated when files are added/removed without a new commit.
+   */
+  private async writeToCache(): Promise<void> {
+    try {
+      const sha = this.readGitShaFast();
+      if (!sha) return;
+
+      const cache = this.container.feature('diskCache') as any;
+      const cacheKey = `file-index:${sha}`;
+
+      // Collect unique directories and their mtimes
+      const dirs: Record<string, number> = {};
+      const files: Record<string, any> = {};
+
+      for (const [key, file] of this.files.entries()) {
+        files[key] = file;
+        if (!dirs[file.dirname]) {
+          try {
+            dirs[file.dirname] = statSync(file.dirname).mtimeMs;
+          } catch {}
+        }
+      }
+
+      await cache.set(cacheKey, { dirs, files });
+    } catch {
+      // Cache write failure is non-fatal
+    }
+  }
+
   /** 
    * Scans the files in the project and updates the file manager state.
    * @param {object} [options={}] - Options for the file manager
@@ -252,14 +382,33 @@ export class FileManager<
     return this.watcher?.getWatched() || {};
   }
 
-  /** 
-   * Watches the files in the project and updates the file manager state.
+  /**
+   * Watches directories for file changes. Can be called multiple times to add
+   * more directories to an existing watcher. Tracks all watched paths in state.
+   *
+   * When called without `paths`, watches the project's `directoryIds` (default behavior).
+   * When called with `paths`, watches only those specific directories/globs.
+   * Subsequent calls add to the existing watcher — they never replace what's already watched.
+   *
    * @param {object} [options={}] - Options for the file manager
+   * @param {string | string[]} [options.paths] - Specific directories or globs to watch. Defaults to project directoryIds.
    * @param {string | string[]} [options.exclude] - The patterns to exclude from the watch
-   * @returns {Promise<void>} The file manager instance
+   * @returns {Promise<void>}
   */
-  async watch(options: { exclude?: string | string[] } = {}) {
-    if (this.isWatching) {
+  async watch(options: { paths?: string | string[]; exclude?: string | string[] } = {}) {
+    const pathsToWatch = castArray(options.paths || this.directoryIds.map(id => this.container.paths.resolve(id)))
+      .map(p => this.container.paths.resolve(p));
+
+    // If already watching, just add the new paths
+    if (this.isWatching && this.watcher) {
+      const currentPaths: string[] = this.state.get("watchedPaths") || [];
+      const newPaths = pathsToWatch.filter(p => !currentPaths.includes(p));
+
+      if (newPaths.length) {
+        this.watcher.add(newPaths);
+        this.state.set("watchedPaths", [...currentPaths, ...newPaths]);
+      }
+
       return;
     }
 
@@ -273,11 +422,7 @@ export class FileManager<
 
     exclude.push(...castArray(this.options.exclude!).filter((v) => v?.length));
 
-    const { cwd } = this.container;
-
-    const watcher = chokidar.watch(
-      this.directoryIds.map(id => this.container.paths.resolve(id)) 
-      , {
+    const watcher = chokidar.watch(pathsToWatch, {
       ignoreInitial: true,
       persistent: true,
       ignored: [
@@ -292,17 +437,17 @@ export class FileManager<
 
     watcher
       .on("add", (path) => {
+        this.updateFile(path);
         this.emit("file:change", {
           type: "add",
           path,
         });
-        this.updateFile(path);
       })
       .on("change", (path) => {
         this.updateFile(path);
         this.emit("file:change", {
-          path,
           type: "change",
+          path,
         });
       })
       .on("unlink", (path) => {
@@ -315,6 +460,7 @@ export class FileManager<
 
     watcher.on("ready", () => {
       this.state.set("watching", true);
+      this.state.set("watchedPaths", pathsToWatch);
     });
 
     this.watcher = watcher;
@@ -328,26 +474,35 @@ export class FileManager<
     if (this.watcher) {
       this.watcher.close();
       this.state.set("watching", false);
+      this.state.set("watchedPaths", []);
       this.watcher = null;
     }
   }
 
   async updateFile(path: string) {
-    // Reuse the logic from the scanFiles method to update a single file
     const absolutePath = this.container.paths.resolve(path);
     const { name, ext, dir } = parse(absolutePath);
-    const stats = statSync(absolutePath);
-
-    this.files.set(path, {
-      dirname: dir,
-      absolutePath,
-      relativePath: path,
-      name,
-      extension: ext,
-      size: stats.size,
-      modifiedAt: stats.mtime,
-      createdAt: stats.birthtime,
-    });
+
+    try {
+      const stats = statSync(absolutePath);
+      this.files.set(path, {
+        dirname: dir,
+        absolutePath,
+        relativePath: path,
+        name,
+        extension: ext,
+        size: stats.size,
+        modifiedAt: stats.mtime,
+        createdAt: stats.birthtime,
+      });
+    } catch (err: any) {
+      // File may have been moved or deleted by an event handler — remove from index gracefully
+      if (err.code === 'ENOENT') {
+        this.files.delete(path);
+      } else {
+        throw err;
+      }
+    }
   }
 
   async removeFile(path: string) {