@karmaniverous/jeeves-watcher 0.18.2 → 0.18.4

package/dist/cli/jeeves-watcher/{index-1dpUCttm.js → index-ChYxOGtD.js}

@@ -747,6 +747,104 @@ class ValuesManager extends BinaryFileStore {
     }
 }
 
+/**
+ * @module watcher/globToDir
+ * Adapts glob-based watch config to chokidar v4+, which removed glob support
+ * (see paulmillr/chokidar#1350). Chokidar v4 treats glob patterns as literal
+ * strings, silently producing zero events. This module extracts static directory
+ * roots from glob patterns for chokidar to watch, then filters emitted events
+ * against the original globs via picomatch.
+ */
+/**
+ * Extract the static directory root from a glob pattern.
+ * Stops at the first segment containing glob characters (`*`, `{`, `?`, `[`).
+ *
+ * @param glob - A glob pattern (e.g., `j:/domains/**\/*.json`).
+ * @returns The static directory prefix (e.g., `j:/domains`).
+ */
+function globRoot(glob) {
+    const normalized = normalizeSlashes(glob);
+    const segments = normalized.split('/');
+    const staticSegments = [];
+    for (const seg of segments) {
+        if (/[*?{[\]]/.test(seg))
+            break;
+        staticSegments.push(seg);
+    }
+    return staticSegments.join('/') || '.';
+}
+/**
+ * Deduplicate directory roots, removing paths that are subdirectories of others.
+ *
+ * @param roots - Array of directory paths.
+ * @returns Deduplicated array with subdirectories removed.
+ */
+function deduplicateRoots(roots) {
+    const normalized = roots.map((r) => normalizeSlashes(r).toLowerCase());
+    const sorted = [...new Set(normalized)].sort();
+    return sorted.filter((root, _i, arr) => {
+        const withSlash = root.endsWith('/') ? root : root + '/';
+        return !arr.some((other) => other !== root && withSlash.startsWith(other + '/'));
+    });
+}
+/**
+ * Build a picomatch matcher from an array of glob patterns.
+ * Normalizes Windows paths (backslash → forward slash, lowercase drive letter)
+ * before matching.
+ *
+ * @param globs - Glob patterns to match against.
+ * @returns A function that tests whether a file path matches any of the globs.
+ */
+function buildGlobMatcher(globs) {
+    const normalizedGlobs = globs.map((g) => normalizeSlashes(g));
+    const isMatch = picomatch(normalizedGlobs, { dot: true, nocase: true });
+    return (filePath) => {
+        const normalized = normalizeSlashes(filePath);
+        return isMatch(normalized);
+    };
+}
+/**
+ * Convert an array of glob patterns into chokidar-compatible directory roots
+ * and a filter function for post-hoc event filtering.
+ *
+ * @param globs - Glob patterns from the watch config.
+ * @returns Object with `roots` (directories for chokidar) and `matches` (filter function).
+ */
+function resolveWatchPaths(globs) {
+    const rawRoots = globs.map(globRoot);
+    const roots = deduplicateRoots(rawRoots);
+    const matches = buildGlobMatcher(globs);
+    return { roots, matches };
+}
+/**
+ * Convert ignored glob patterns to picomatch matcher functions.
+ *
+ * Chokidar v5 replaced the external `anymatch` dependency with an inline
+ * implementation that does **exact string equality** for string matchers,
+ * breaking glob-based `ignored` patterns. This function converts glob strings
+ * to picomatch functions that chokidar's `createPattern` passes through
+ * unchanged (`typeof matcher === 'function'`).
+ *
+ * Non-string entries (functions, RegExps) are passed through as-is.
+ *
+ * @param ignored - Array of ignored patterns (globs, functions, RegExps).
+ * @returns Array with glob strings replaced by picomatch matcher functions.
+ */
+function resolveIgnored(ignored) {
+    return ignored.map((entry) => {
+        if (typeof entry !== 'string')
+            return entry;
+        // If the string contains glob characters, convert to a picomatch function.
+        // Literal strings (exact paths) are also converted for consistent matching.
+        const normalizedPattern = normalizeSlashes(entry);
+        const matcher = picomatch(normalizedPattern, { dot: true, nocase: true });
+        return (filePath) => {
+            const normalized = normalizeSlashes(filePath);
+            return matcher(normalized);
+        };
+    });
+}
+
 /**
  * @module vcs/CommitMessageGenerator
  * Generates AI-powered commit messages via the Anthropic Messages API.
@@ -836,17 +934,32 @@ class CommitMessageGenerator {
  */
 /** Promisified execFile for git commands. */
 const execFileAsync = promisify(execFile);
+/**
+ * Normalize a path for case-insensitive comparison on Windows.
+ * On Windows, lowercases the entire path; on other platforms, returns as-is.
+ *
+ * @param p - The path string to normalize.
+ * @param platform - The platform to check against (default: `process.platform`).
+ * @returns The normalized path.
+ */
+function normalizePathCase(p, platform = process.platform) {
+    return platform === 'win32' ? p.toLowerCase() : p;
+}
 /**
  * Find the longest-prefix-match root for a normalized path.
  * Roots must be sorted longest-first for correct nested matching.
  *
  * @param roots - Root paths sorted longest-first.
  * @param normalizedPath - Normalized absolute path (forward slashes).
+ * @param platform - The platform to check against (default: `process.platform`).
  * @returns The matching root, or undefined.
  */
-function findRootForPath(roots, normalizedPath) {
+function findRootForPath(roots, normalizedPath, platform = process.platform) {
+    const comparePath = normalizePathCase(normalizedPath, platform);
     for (const root of roots) {
-        if (normalizedPath === root || normalizedPath.startsWith(root + '/')) {
+        const compareRoot = normalizePathCase(root, platform);
+        if (comparePath === compareRoot ||
+            comparePath.startsWith(compareRoot + '/')) {
             return root;
         }
     }
@@ -1205,6 +1318,7 @@ class VcsManager {
     debounceTimer;
     commitInFlight = Promise.resolve();
     started = false;
+    isBaseline = false;
     _lastPushTime = null;
     constructor(rootPath, config, logger, commitMessageGenerator, remoteUrl, accessToken) {
         this.rootPath = rootPath;
@@ -1225,11 +1339,47 @@ class VcsManager {
     }
     /**
      * Begin accepting file changes. Sets up the debounce mechanism.
+     * Enqueues a baseline commit for pre-existing files if the repo has no commits.
      */
-    start() {
+    async start() {
         this.started = true;
         this.squashManager?.start();
         this.logger.info({ root: this.rootPath }, 'VcsManager started');
+        await this.enqueueBaselineIfNeeded();
+    }
+    /**
+     * If the repo has no commits, enumerate untracked files and feed them
+     * through fileChanged() to create a baseline commit.
+     */
+    async enqueueBaselineIfNeeded() {
+        try {
+            await execFileAsync('git', ['rev-parse', 'HEAD'], {
+                cwd: this.rootPath,
+            });
+            // HEAD exists — repo already has commits
+            return;
+        }
+        catch {
+            // No commits yet — proceed with baseline
+        }
+        try {
+            const { stdout } = await execFileAsync('git', ['ls-files', '--others', '--exclude-standard', '-z'], { cwd: this.rootPath });
+            const files = stdout
+                .split('\0')
+                .map((line) => line.trim())
+                .filter((line) => line.length > 0);
+            if (files.length === 0)
+                return;
+            this.logger.info({ root: this.rootPath, fileCount: files.length }, 'Enqueuing baseline commit for pre-existing files');
+            this.isBaseline = true;
+            const absolutePaths = files.map((f) => this.rootPath + '/' + f);
+            for (const filePath of absolutePaths) {
+                this.fileChanged(filePath);
+            }
+        }
+        catch (error) {
+            this.logger.warn({ root: this.rootPath, err: normalizeError(error) }, 'Failed to enumerate untracked files for baseline commit');
+        }
     }
     /**
      * Add a file to the pending set and reset the debounce timer.
@@ -1344,6 +1494,9 @@ class VcsManager {
      */
     buildTemplateMessage(fileCount) {
         if (this.pendingReversions.length === 0) {
+            if (this.isBaseline) {
+                return `baseline: batch (${String(fileCount)} files)`;
+            }
             const timestamp = new Date().toISOString();
             return `watcher: batch ${timestamp} (${String(fileCount)} files)`;
         }
@@ -1401,10 +1554,15 @@ class VcsManager {
                     cwd: this.rootPath,
                 });
                 // Build message after staging so getStagedDiff can see the changes
-                const message = attempt === 1
-                    ? await this.buildCommitMessage(files)
-                    : this.buildTemplateMessage(files.length);
+                // Skip AI for baselines and retries — use template directly
+                const message = this.isBaseline || attempt > 1
+                    ? this.buildTemplateMessage(files.length)
+                    : await this.buildCommitMessage(files);
                 this.pendingReversions.length = 0;
+                // Only clear baseline flag when all baseline files have been committed
+                if (this.pending.size === 0) {
+                    this.isBaseline = false;
+                }
                 await execFileAsync('git', ['commit', '-m', message], {
                     cwd: this.rootPath,
                 });
@@ -1480,11 +1638,11 @@ class VcsCoordinator {
             const rootVcs = entry.vcs?.enabled ?? config.vcs.enabled;
             if (!rootVcs)
                 continue;
-            if (/[*?{[]/.test(entry.path)) {
-                logger.warn({ path: entry.path }, 'Skipping VCS for watch path containing glob characters');
+            const resolvedRoot = normalizeSlashes(resolve(globRoot(entry.path)));
+            const rootKey = normalizePathCase(resolvedRoot);
+            // Deduplicate: skip if another glob already resolved to this root.
+            if (this.managers.has(rootKey))
                 continue;
-            }
-            const resolvedRoot = normalizeSlashes(resolve(entry.path));
             const mergedConfig = {
                 ...config.vcs,
                 ...entry.vcs,
@@ -1503,7 +1661,7 @@ class VcsCoordinator {
             const remoteUrl = entry.vcs?.remote;
             const accessToken = entry.vcs?.accessToken ?? config.vcs.defaultAccessToken;
             const manager = new VcsManager(resolvedRoot, mergedConfig, logger.child({ vcsRoot: resolvedRoot }), generator, remoteUrl, accessToken);
-            this.managers.set(resolvedRoot, manager);
+            this.managers.set(rootKey, manager);
             this.roots.push(resolvedRoot);
         }
         // Sort roots longest-first so nested paths match before parents.
@@ -1512,10 +1670,12 @@ class VcsCoordinator {
     /**
      * Start all VcsManager instances.
      */
-    start() {
+    async start() {
+        const startPromises = [];
         this.managers.forEach((manager) => {
-            manager.start();
+            startPromises.push(manager.start());
         });
+        await Promise.all(startPromises);
         this.logger.info({ rootCount: this.managers.size }, 'VcsCoordinator started');
     }
     /**
@@ -1557,7 +1717,7 @@ class VcsCoordinator {
      * Get the VcsManager for a specific root path.
      */
     getManager(root) {
-        return this.managers.get(root);
+        return this.managers.get(normalizePathCase(root));
     }
     /**
      * Get all managers as [root, manager] pairs.
@@ -1574,7 +1734,7 @@ class VcsCoordinator {
      */
     findManagerForPath(normalizedPath) {
         const root = findRootForPath(this.roots, normalizedPath);
-        return root ? this.managers.get(root) : undefined;
+        return root ? this.managers.get(normalizePathCase(root)) : undefined;
     }
 }
 
@@ -2795,15 +2955,18 @@ function resolveWatchRootsForGlob(coordinator, glob) {
     const normalizedGlob = normalizeSlashes(glob);
     const roots = coordinator.getRoots();
     const results = [];
+    const compareGlob = normalizePathCase(normalizedGlob);
     for (const root of roots) {
-        if (normalizedGlob.startsWith(root + '/') || normalizedGlob === root) {
+        const compareRoot = normalizePathCase(root);
+        if (compareGlob.startsWith(compareRoot + '/') ||
+            compareGlob === compareRoot) {
             // Glob is under this root
             results.push({
                 root,
                 relativePath: normalizeSlashes(relative(root, normalizedGlob)),
             });
         }
-        else if (root.startsWith(normalizedGlob.replace(/[*?[\]{}]/g, ''))) {
+        else if (compareRoot.startsWith(compareGlob.replace(/[*?[\]{}]/g, ''))) {
             // Root is under the glob's base path — include with root-relative glob
             results.push({
                 root,
@@ -3088,20 +3251,22 @@ async function initVcs(config, logger) {
     }
     const stateDir = config.stateDir ?? '.jeeves-metadata';
     const pathStrings = extractWatchPathStrings(config.watch.paths);
-    const staticPaths = pathStrings.filter((p) => !/[*?{[]/.test(p));
+    const staticPaths = pathStrings.map((p) => globRoot(p));
     validateStateDirOverlap(stateDir, staticPaths);
     const normalized = normalizeWatchPaths(config.watch.paths);
+    const initializedRoots = new Set();
     for (const entry of normalized) {
         const rootVcs = entry.vcs?.enabled ?? config.vcs.enabled;
         if (!rootVcs)
             continue;
-        if (/[*?{[]/.test(entry.path)) {
-            logger.warn({ path: entry.path }, 'Skipping VCS init for watch path containing glob characters');
+        const root = globRoot(entry.path);
+        // Deduplicate: skip if another glob already resolved to this root.
+        if (initializedRoots.has(root))
             continue;
-        }
-        await initRepo(entry.path);
-        await ensureGitignore(entry.path);
-        logger.info({ root: entry.path }, 'VCS initialized for watch root');
+        initializedRoots.add(root);
+        await initRepo(root);
+        await ensureGitignore(root);
+        logger.info({ root }, 'VCS initialized for watch root');
     }
     return true;
 }
@@ -7054,104 +7219,6 @@ class SystemHealth {
     }
 }
 
-/**
- * @module watcher/globToDir
- * Adapts glob-based watch config to chokidar v4+, which removed glob support
- * (see paulmillr/chokidar#1350). Chokidar v4 treats glob patterns as literal
- * strings, silently producing zero events. This module extracts static directory
- * roots from glob patterns for chokidar to watch, then filters emitted events
- * against the original globs via picomatch.
- */
-/**
- * Extract the static directory root from a glob pattern.
- * Stops at the first segment containing glob characters (`*`, `{`, `?`, `[`).
- *
- * @param glob - A glob pattern (e.g., `j:/domains/**\/*.json`).
- * @returns The static directory prefix (e.g., `j:/domains`).
- */
-function globRoot(glob) {
-    const normalized = normalizeSlashes(glob);
-    const segments = normalized.split('/');
-    const staticSegments = [];
-    for (const seg of segments) {
-        if (/[*?{[\]]/.test(seg))
-            break;
-        staticSegments.push(seg);
-    }
-    return staticSegments.join('/') || '.';
-}
-/**
- * Deduplicate directory roots, removing paths that are subdirectories of others.
- *
- * @param roots - Array of directory paths.
- * @returns Deduplicated array with subdirectories removed.
- */
-function deduplicateRoots(roots) {
-    const normalized = roots.map((r) => normalizeSlashes(r).toLowerCase());
-    const sorted = [...new Set(normalized)].sort();
-    return sorted.filter((root, _i, arr) => {
-        const withSlash = root.endsWith('/') ? root : root + '/';
-        return !arr.some((other) => other !== root && withSlash.startsWith(other + '/'));
-    });
-}
-/**
- * Build a picomatch matcher from an array of glob patterns.
- * Normalizes Windows paths (backslash → forward slash, lowercase drive letter)
- * before matching.
- *
- * @param globs - Glob patterns to match against.
- * @returns A function that tests whether a file path matches any of the globs.
- */
-function buildGlobMatcher(globs) {
-    const normalizedGlobs = globs.map((g) => normalizeSlashes(g));
-    const isMatch = picomatch(normalizedGlobs, { dot: true, nocase: true });
-    return (filePath) => {
-        const normalized = normalizeSlashes(filePath);
-        return isMatch(normalized);
-    };
-}
-/**
- * Convert an array of glob patterns into chokidar-compatible directory roots
- * and a filter function for post-hoc event filtering.
- *
- * @param globs - Glob patterns from the watch config.
- * @returns Object with `roots` (directories for chokidar) and `matches` (filter function).
- */
-function resolveWatchPaths(globs) {
-    const rawRoots = globs.map(globRoot);
-    const roots = deduplicateRoots(rawRoots);
-    const matches = buildGlobMatcher(globs);
-    return { roots, matches };
-}
-/**
- * Convert ignored glob patterns to picomatch matcher functions.
- *
- * Chokidar v5 replaced the external `anymatch` dependency with an inline
- * implementation that does **exact string equality** for string matchers,
- * breaking glob-based `ignored` patterns. This function converts glob strings
- * to picomatch functions that chokidar's `createPattern` passes through
- * unchanged (`typeof matcher === 'function'`).
- *
- * Non-string entries (functions, RegExps) are passed through as-is.
- *
- * @param ignored - Array of ignored patterns (globs, functions, RegExps).
- * @returns Array with glob strings replaced by picomatch matcher functions.
- */
-function resolveIgnored(ignored) {
-    return ignored.map((entry) => {
-        if (typeof entry !== 'string')
-            return entry;
-        // If the string contains glob characters, convert to a picomatch function.
-        // Literal strings (exact paths) are also converted for consistent matching.
-        const normalizedPattern = normalizeSlashes(entry);
-        const matcher = picomatch(normalizedPattern, { dot: true, nocase: true });
-        return (filePath) => {
-            const normalized = normalizeSlashes(filePath);
-            return matcher(normalized);
-        };
-    });
-}
-
 /**
  * @module watcher/MoveCorrelator
  * Correlates unlink+add events as file moves using content hash matching.
@@ -7693,7 +7760,7 @@ class JeevesWatcher {
         this.watcher = watcher;
         this.gitignoreFilter = gitignoreFilter;
         this.server = await this.startApiServer();
-        vcsCoordinator.start();
+        await vcsCoordinator.start();
         this.watcher.start();
         this.startConfigWatch();
         logger.info('jeeves-watcher started');

package/dist/cli/jeeves-watcher/index.js

@@ -224,7 +224,7 @@ async function startFromConfig(configPath, descriptor) {
     const config = await loadConfig(resolvedPath);
     // Dynamic import breaks the circular dependency between this module
     // and app/index.ts (which defines JeevesWatcher and re-exports startFromConfig).
-    const { JeevesWatcher } = await import('./index-1dpUCttm.js');
+    const { JeevesWatcher } = await import('./index-ChYxOGtD.js');
     const app = new JeevesWatcher(config, resolvedPath, descriptor);
     installShutdownHandlers(() => app.stop());
     await app.start();

package/dist/index.d.ts

@@ -1291,14 +1291,21 @@ declare class VcsManager {
     private debounceTimer;
     private commitInFlight;
     private started;
+    private isBaseline;
     private _lastPushTime;
     constructor(rootPath: string, config: VcsConfig, logger: pino.Logger, commitMessageGenerator?: CommitMessageGenerator, remoteUrl?: string, accessToken?: string);
     get lastPushTime(): string | null;
     get pushErrors(): readonly PushError[];
     /**
      * Begin accepting file changes. Sets up the debounce mechanism.
+     * Enqueues a baseline commit for pre-existing files if the repo has no commits.
      */
-    start(): void;
+    start(): Promise<void>;
+    /**
+     * If the repo has no commits, enumerate untracked files and feed them
+     * through fileChanged() to create a baseline commit.
+     */
+    private enqueueBaselineIfNeeded;
     /**
      * Add a file to the pending set and reset the debounce timer.
      * If the pending set exceeds maxBatchSize, flush immediately.
@@ -1379,7 +1386,7 @@ declare class VcsCoordinator {
     /**
      * Start all VcsManager instances.
      */
-    start(): void;
+    start(): Promise<void>;
     /**
      * Route a file event to the correct root's VcsManager.
      *

package/dist/index.js

@@ -3375,17 +3375,32 @@ function createSearchHandler(deps) {
  */
 /** Promisified execFile for git commands. */
 const execFileAsync = promisify(execFile);
+/**
+ * Normalize a path for case-insensitive comparison on Windows.
+ * On Windows, lowercases the entire path; on other platforms, returns as-is.
+ *
+ * @param p - The path string to normalize.
+ * @param platform - The platform to check against (default: `process.platform`).
+ * @returns The normalized path.
+ */
+function normalizePathCase(p, platform = process.platform) {
+    return platform === 'win32' ? p.toLowerCase() : p;
+}
 /**
  * Find the longest-prefix-match root for a normalized path.
  * Roots must be sorted longest-first for correct nested matching.
  *
  * @param roots - Root paths sorted longest-first.
  * @param normalizedPath - Normalized absolute path (forward slashes).
+ * @param platform - The platform to check against (default: `process.platform`).
  * @returns The matching root, or undefined.
  */
-function findRootForPath(roots, normalizedPath) {
+function findRootForPath(roots, normalizedPath, platform = process.platform) {
+    const comparePath = normalizePathCase(normalizedPath, platform);
     for (const root of roots) {
-        if (normalizedPath === root || normalizedPath.startsWith(root + '/')) {
+        const compareRoot = normalizePathCase(root, platform);
+        if (comparePath === compareRoot ||
+            comparePath.startsWith(compareRoot + '/')) {
             return root;
         }
     }
@@ -3425,15 +3440,18 @@ function resolveWatchRootsForGlob(coordinator, glob) {
     const normalizedGlob = normalizeSlashes(glob);
     const roots = coordinator.getRoots();
     const results = [];
+    const compareGlob = normalizePathCase(normalizedGlob);
     for (const root of roots) {
-        if (normalizedGlob.startsWith(root + '/') || normalizedGlob === root) {
+        const compareRoot = normalizePathCase(root);
+        if (compareGlob.startsWith(compareRoot + '/') ||
+            compareGlob === compareRoot) {
             // Glob is under this root
             results.push({
                 root,
                 relativePath: normalizeSlashes(relative(root, normalizedGlob)),
             });
         }
-        else if (root.startsWith(normalizedGlob.replace(/[*?[\]{}]/g, ''))) {
+        else if (compareRoot.startsWith(compareGlob.replace(/[*?[\]{}]/g, ''))) {
             // Root is under the glob's base path — include with root-relative glob
             results.push({
                 root,
@@ -4654,6 +4672,104 @@ async function ensureGitignore(rootPath, alwaysOnEntries = []) {
     }
 }
 
+/**
+ * @module watcher/globToDir
+ * Adapts glob-based watch config to chokidar v4+, which removed glob support
+ * (see paulmillr/chokidar#1350). Chokidar v4 treats glob patterns as literal
+ * strings, silently producing zero events. This module extracts static directory
+ * roots from glob patterns for chokidar to watch, then filters emitted events
+ * against the original globs via picomatch.
+ */
+/**
+ * Extract the static directory root from a glob pattern.
+ * Stops at the first segment containing glob characters (`*`, `{`, `?`, `[`).
+ *
+ * @param glob - A glob pattern (e.g., `j:/domains/**\/*.json`).
+ * @returns The static directory prefix (e.g., `j:/domains`).
+ */
+function globRoot(glob) {
+    const normalized = normalizeSlashes(glob);
+    const segments = normalized.split('/');
+    const staticSegments = [];
+    for (const seg of segments) {
+        if (/[*?{[\]]/.test(seg))
+            break;
+        staticSegments.push(seg);
+    }
+    return staticSegments.join('/') || '.';
+}
+/**
+ * Deduplicate directory roots, removing paths that are subdirectories of others.
+ *
+ * @param roots - Array of directory paths.
+ * @returns Deduplicated array with subdirectories removed.
+ */
+function deduplicateRoots(roots) {
+    const normalized = roots.map((r) => normalizeSlashes(r).toLowerCase());
+    const sorted = [...new Set(normalized)].sort();
+    return sorted.filter((root, _i, arr) => {
+        const withSlash = root.endsWith('/') ? root : root + '/';
+        return !arr.some((other) => other !== root && withSlash.startsWith(other + '/'));
+    });
+}
+/**
+ * Build a picomatch matcher from an array of glob patterns.
+ * Normalizes Windows paths (backslash → forward slash, lowercase drive letter)
+ * before matching.
+ *
+ * @param globs - Glob patterns to match against.
+ * @returns A function that tests whether a file path matches any of the globs.
+ */
+function buildGlobMatcher(globs) {
+    const normalizedGlobs = globs.map((g) => normalizeSlashes(g));
+    const isMatch = picomatch(normalizedGlobs, { dot: true, nocase: true });
+    return (filePath) => {
+        const normalized = normalizeSlashes(filePath);
+        return isMatch(normalized);
+    };
+}
+/**
+ * Convert an array of glob patterns into chokidar-compatible directory roots
+ * and a filter function for post-hoc event filtering.
+ *
+ * @param globs - Glob patterns from the watch config.
+ * @returns Object with `roots` (directories for chokidar) and `matches` (filter function).
+ */
+function resolveWatchPaths(globs) {
+    const rawRoots = globs.map(globRoot);
+    const roots = deduplicateRoots(rawRoots);
+    const matches = buildGlobMatcher(globs);
+    return { roots, matches };
+}
+/**
+ * Convert ignored glob patterns to picomatch matcher functions.
+ *
+ * Chokidar v5 replaced the external `anymatch` dependency with an inline
+ * implementation that does **exact string equality** for string matchers,
+ * breaking glob-based `ignored` patterns. This function converts glob strings
+ * to picomatch functions that chokidar's `createPattern` passes through
+ * unchanged (`typeof matcher === 'function'`).
+ *
+ * Non-string entries (functions, RegExps) are passed through as-is.
+ *
+ * @param ignored - Array of ignored patterns (globs, functions, RegExps).
+ * @returns Array with glob strings replaced by picomatch matcher functions.
+ */
+function resolveIgnored(ignored) {
+    return ignored.map((entry) => {
+        if (typeof entry !== 'string')
+            return entry;
+        // If the string contains glob characters, convert to a picomatch function.
+        // Literal strings (exact paths) are also converted for consistent matching.
+        const normalizedPattern = normalizeSlashes(entry);
+        const matcher = picomatch(normalizedPattern, { dot: true, nocase: true });
+        return (filePath) => {
+            const normalized = normalizeSlashes(filePath);
+            return matcher(normalized);
+        };
+    });
+}
+
 /**
  * @module vcs/VcsManager
  * Per-root VCS manager for git-backed content versioning.
@@ -4682,6 +4798,7 @@ class VcsManager {
     debounceTimer;
     commitInFlight = Promise.resolve();
     started = false;
+    isBaseline = false;
     _lastPushTime = null;
     constructor(rootPath, config, logger, commitMessageGenerator, remoteUrl, accessToken) {
         this.rootPath = rootPath;
@@ -4702,11 +4819,47 @@ class VcsManager {
     }
     /**
      * Begin accepting file changes. Sets up the debounce mechanism.
+     * Enqueues a baseline commit for pre-existing files if the repo has no commits.
      */
-    start() {
+    async start() {
         this.started = true;
         this.squashManager?.start();
         this.logger.info({ root: this.rootPath }, 'VcsManager started');
+        await this.enqueueBaselineIfNeeded();
+    }
+    /**
+     * If the repo has no commits, enumerate untracked files and feed them
+     * through fileChanged() to create a baseline commit.
+     */
+    async enqueueBaselineIfNeeded() {
+        try {
+            await execFileAsync('git', ['rev-parse', 'HEAD'], {
+                cwd: this.rootPath,
+            });
+            // HEAD exists — repo already has commits
+            return;
+        }
+        catch {
+            // No commits yet — proceed with baseline
+        }
+        try {
+            const { stdout } = await execFileAsync('git', ['ls-files', '--others', '--exclude-standard', '-z'], { cwd: this.rootPath });
+            const files = stdout
+                .split('\0')
+                .map((line) => line.trim())
+                .filter((line) => line.length > 0);
+            if (files.length === 0)
+                return;
+            this.logger.info({ root: this.rootPath, fileCount: files.length }, 'Enqueuing baseline commit for pre-existing files');
+            this.isBaseline = true;
+            const absolutePaths = files.map((f) => this.rootPath + '/' + f);
+            for (const filePath of absolutePaths) {
+                this.fileChanged(filePath);
+            }
+        }
+        catch (error) {
+            this.logger.warn({ root: this.rootPath, err: normalizeError(error) }, 'Failed to enumerate untracked files for baseline commit');
+        }
     }
     /**
      * Add a file to the pending set and reset the debounce timer.
@@ -4821,6 +4974,9 @@ class VcsManager {
      */
     buildTemplateMessage(fileCount) {
         if (this.pendingReversions.length === 0) {
+            if (this.isBaseline) {
+                return `baseline: batch (${String(fileCount)} files)`;
+            }
             const timestamp = new Date().toISOString();
             return `watcher: batch ${timestamp} (${String(fileCount)} files)`;
         }
@@ -4878,10 +5034,15 @@ class VcsManager {
                     cwd: this.rootPath,
                 });
                 // Build message after staging so getStagedDiff can see the changes
-                const message = attempt === 1
-                    ? await this.buildCommitMessage(files)
-                    : this.buildTemplateMessage(files.length);
+                // Skip AI for baselines and retries — use template directly
+                const message = this.isBaseline || attempt > 1
+                    ? this.buildTemplateMessage(files.length)
+                    : await this.buildCommitMessage(files);
                 this.pendingReversions.length = 0;
+                // Only clear baseline flag when all baseline files have been committed
+                if (this.pending.size === 0) {
+                    this.isBaseline = false;
+                }
                 await execFileAsync('git', ['commit', '-m', message], {
                     cwd: this.rootPath,
                 });
@@ -4957,11 +5118,11 @@ class VcsCoordinator {
             const rootVcs = entry.vcs?.enabled ?? config.vcs.enabled;
             if (!rootVcs)
                 continue;
-            if (/[*?{[]/.test(entry.path)) {
-                logger.warn({ path: entry.path }, 'Skipping VCS for watch path containing glob characters');
+            const resolvedRoot = normalizeSlashes(resolve(globRoot(entry.path)));
+            const rootKey = normalizePathCase(resolvedRoot);
+            // Deduplicate: skip if another glob already resolved to this root.
+            if (this.managers.has(rootKey))
                 continue;
-            }
-            const resolvedRoot = normalizeSlashes(resolve(entry.path));
             const mergedConfig = {
                 ...config.vcs,
                 ...entry.vcs,
@@ -4980,7 +5141,7 @@ class VcsCoordinator {
             const remoteUrl = entry.vcs?.remote;
             const accessToken = entry.vcs?.accessToken ?? config.vcs.defaultAccessToken;
             const manager = new VcsManager(resolvedRoot, mergedConfig, logger.child({ vcsRoot: resolvedRoot }), generator, remoteUrl, accessToken);
-            this.managers.set(resolvedRoot, manager);
+            this.managers.set(rootKey, manager);
             this.roots.push(resolvedRoot);
         }
         // Sort roots longest-first so nested paths match before parents.
@@ -4989,10 +5150,12 @@ class VcsCoordinator {
     /**
      * Start all VcsManager instances.
      */
-    start() {
+    async start() {
+        const startPromises = [];
         this.managers.forEach((manager) => {
-            manager.start();
+            startPromises.push(manager.start());
         });
+        await Promise.all(startPromises);
         this.logger.info({ rootCount: this.managers.size }, 'VcsCoordinator started');
     }
     /**
@@ -5034,7 +5197,7 @@ class VcsCoordinator {
      * Get the VcsManager for a specific root path.
      */
     getManager(root) {
-        return this.managers.get(root);
+        return this.managers.get(normalizePathCase(root));
     }
     /**
      * Get all managers as [root, manager] pairs.
@@ -5051,7 +5214,7 @@ class VcsCoordinator {
      */
     findManagerForPath(normalizedPath) {
         const root = findRootForPath(this.roots, normalizedPath);
-        return root ? this.managers.get(root) : undefined;
+        return root ? this.managers.get(normalizePathCase(root)) : undefined;
     }
 }
 
@@ -5224,20 +5387,22 @@ async function initVcs(config, logger) {
     }
     const stateDir = config.stateDir ?? '.jeeves-metadata';
     const pathStrings = extractWatchPathStrings(config.watch.paths);
-    const staticPaths = pathStrings.filter((p) => !/[*?{[]/.test(p));
+    const staticPaths = pathStrings.map((p) => globRoot(p));
     validateStateDirOverlap(stateDir, staticPaths);
     const normalized = normalizeWatchPaths(config.watch.paths);
+    const initializedRoots = new Set();
     for (const entry of normalized) {
         const rootVcs = entry.vcs?.enabled ?? config.vcs.enabled;
         if (!rootVcs)
             continue;
-        if (/[*?{[]/.test(entry.path)) {
-            logger.warn({ path: entry.path }, 'Skipping VCS init for watch path containing glob characters');
+        const root = globRoot(entry.path);
+        // Deduplicate: skip if another glob already resolved to this root.
+        if (initializedRoots.has(root))
             continue;
-        }
-        await initRepo(entry.path);
-        await ensureGitignore(entry.path);
-        logger.info({ root: entry.path }, 'VCS initialized for watch root');
+        initializedRoots.add(root);
+        await initRepo(root);
+        await ensureGitignore(root);
+        logger.info({ root }, 'VCS initialized for watch root');
     }
     return true;
 }
@@ -8093,104 +8258,6 @@ class SystemHealth {
     }
 }
 
-/**
- * @module watcher/globToDir
- * Adapts glob-based watch config to chokidar v4+, which removed glob support
- * (see paulmillr/chokidar#1350). Chokidar v4 treats glob patterns as literal
- * strings, silently producing zero events. This module extracts static directory
- * roots from glob patterns for chokidar to watch, then filters emitted events
- * against the original globs via picomatch.
- */
-/**
- * Extract the static directory root from a glob pattern.
- * Stops at the first segment containing glob characters (`*`, `{`, `?`, `[`).
- *
- * @param glob - A glob pattern (e.g., `j:/domains/**\/*.json`).
- * @returns The static directory prefix (e.g., `j:/domains`).
- */
-function globRoot(glob) {
-    const normalized = normalizeSlashes(glob);
-    const segments = normalized.split('/');
-    const staticSegments = [];
-    for (const seg of segments) {
-        if (/[*?{[\]]/.test(seg))
-            break;
-        staticSegments.push(seg);
-    }
-    return staticSegments.join('/') || '.';
-}
-/**
- * Deduplicate directory roots, removing paths that are subdirectories of others.
- *
- * @param roots - Array of directory paths.
- * @returns Deduplicated array with subdirectories removed.
- */
-function deduplicateRoots(roots) {
-    const normalized = roots.map((r) => normalizeSlashes(r).toLowerCase());
-    const sorted = [...new Set(normalized)].sort();
-    return sorted.filter((root, _i, arr) => {
-        const withSlash = root.endsWith('/') ? root : root + '/';
-        return !arr.some((other) => other !== root && withSlash.startsWith(other + '/'));
-    });
-}
-/**
- * Build a picomatch matcher from an array of glob patterns.
- * Normalizes Windows paths (backslash → forward slash, lowercase drive letter)
- * before matching.
- *
- * @param globs - Glob patterns to match against.
- * @returns A function that tests whether a file path matches any of the globs.
- */
-function buildGlobMatcher(globs) {
-    const normalizedGlobs = globs.map((g) => normalizeSlashes(g));
-    const isMatch = picomatch(normalizedGlobs, { dot: true, nocase: true });
-    return (filePath) => {
-        const normalized = normalizeSlashes(filePath);
-        return isMatch(normalized);
-    };
-}
-/**
- * Convert an array of glob patterns into chokidar-compatible directory roots
- * and a filter function for post-hoc event filtering.
- *
- * @param globs - Glob patterns from the watch config.
- * @returns Object with `roots` (directories for chokidar) and `matches` (filter function).
- */
-function resolveWatchPaths(globs) {
-    const rawRoots = globs.map(globRoot);
-    const roots = deduplicateRoots(rawRoots);
-    const matches = buildGlobMatcher(globs);
-    return { roots, matches };
-}
-/**
- * Convert ignored glob patterns to picomatch matcher functions.
- *
- * Chokidar v5 replaced the external `anymatch` dependency with an inline
- * implementation that does **exact string equality** for string matchers,
- * breaking glob-based `ignored` patterns. This function converts glob strings
- * to picomatch functions that chokidar's `createPattern` passes through
- * unchanged (`typeof matcher === 'function'`).
- *
- * Non-string entries (functions, RegExps) are passed through as-is.
- *
- * @param ignored - Array of ignored patterns (globs, functions, RegExps).
- * @returns Array with glob strings replaced by picomatch matcher functions.
- */
-function resolveIgnored(ignored) {
-    return ignored.map((entry) => {
-        if (typeof entry !== 'string')
-            return entry;
-        // If the string contains glob characters, convert to a picomatch function.
-        // Literal strings (exact paths) are also converted for consistent matching.
-        const normalizedPattern = normalizeSlashes(entry);
-        const matcher = picomatch(normalizedPattern, { dot: true, nocase: true });
-        return (filePath) => {
-            const normalized = normalizeSlashes(filePath);
-            return matcher(normalized);
-        };
-    });
-}
-
 /**
  * @module watcher/MoveCorrelator
  * Correlates unlink+add events as file moves using content hash matching.
@@ -8844,7 +8911,7 @@ class JeevesWatcher {
         this.watcher = watcher;
         this.gitignoreFilter = gitignoreFilter;
         this.server = await this.startApiServer();
-        vcsCoordinator.start();
+        await vcsCoordinator.start();
         this.watcher.start();
         this.startConfigWatch();
         logger.info('jeeves-watcher started');

package/package.json

@@ -149,5 +149,5 @@
   },
   "type": "module",
   "types": "dist/index.d.ts",
-  "version": "0.18.2"
+  "version": "0.18.4"
 }