aiden-runtime 4.1.5 → 4.5.0

package/dist/core/v4/daemon/triggers/fileWatcher.js

@@ -0,0 +1,253 @@
+"use strict";
+/**
+ * Copyright (c) 2026 Shiva Deore (Taracod).
+ * Licensed under AGPL-3.0. See LICENSE for details.
+ *
+ * Aiden — local-first agent.
+ */
+/**
+ * core/v4/daemon/triggers/fileWatcher.ts — v4.5 Phase 2: the
+ * file-watcher trigger source.
+ *
+ * Wires chokidar 4.x into the Phase 1 trigger bus. One module-level
+ * factory `createFileWatcher(spec)` returns a handle that:
+ *   - subscribes to add/change/unlink events
+ *   - filters via the glob matcher (default ignores + spec globs)
+ *   - debounces per-path (default 750ms)
+ *   - settles via a stat loop (default 1s) — second layer on top
+ *     of chokidar's `awaitWriteFinish`
+ *   - upserts a file_observations row + inserts a trigger_event
+ *     under the bus's UNIQUE(source, idempotency_key) dedup
+ *   - registers itself in the resourceRegistry for shutdown reap
+ *   - exposes `stats()` for /metrics + diagnostics
+ *
+ * Backpressure: per-watcher queue depth (default 100). When full,
+ * new events DROP with a log + stats counter bump (Q-P2-5 default).
+ * Pausing chokidar would cause a resync-burst on resume — drop-new
+ * is the correct trade-off.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createFileWatcher = createFileWatcher;
+const chokidar_1 = __importDefault(require("chokidar"));
+const node_path_1 = __importDefault(require("node:path"));
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_crypto_1 = __importDefault(require("node:crypto"));
+const globMatcher_1 = require("./globMatcher");
+const fsIdentity_1 = require("./fsIdentity");
+const settleStat_1 = require("./settleStat");
+const noopLog = (_level, _msg) => undefined;
+function createFileWatcher(opts) {
+    const { watcherId, spec, triggerBus, obsStore, registry } = opts;
+    const log = opts.log ?? noopLog;
+    const matcher = (0, globMatcher_1.compileGlobMatcher)({
+        includeGlobs: spec.includeGlobs,
+        excludeGlobs: spec.excludeGlobs,
+        ignoreTemp: spec.ignoreTemp,
+    });
+    // Per-path pending queue. Map key = absPath; one entry per path.
+    const queue = new Map();
+    const acceptedEventTypes = new Set(spec.eventTypes);
+    let paused = false;
+    const stats = {
+        queueDepth: 0,
+        emitted: 0,
+        coalesced: 0,
+        skipped: 0,
+        dropped: 0,
+        overflowed: false,
+        lastError: null,
+    };
+    // ── chokidar setup ──────────────────────────────────────────────────────
+    const watcher = chokidar_1.default.watch(spec.paths, {
+        persistent: true,
+        ignoreInitial: true, // boot-time reconciliation runs separately
+        depth: spec.recursive ? undefined : 0,
+        awaitWriteFinish: {
+            stabilityThreshold: Math.max(50, spec.settleMs),
+            pollInterval: 100,
+        },
+        usePolling: spec.polling?.enabled === true,
+        interval: spec.polling?.intervalMs,
+        binaryInterval: spec.polling?.binaryIntervalMs,
+        // chokidar 4.x removed built-in globs — we filter via picomatch
+        // in handleEvent below.
+    });
+    // ── core event handler ──────────────────────────────────────────────────
+    const handleEvent = (eventType, absPath) => {
+        if (paused)
+            return;
+        if (!acceptedEventTypes.has(eventType)) {
+            stats.skipped += 1;
+            return;
+        }
+        if (!matcher.match(absPath)) {
+            stats.skipped += 1;
+            return;
+        }
+        // Unlink bypasses debounce + settle — the file is gone.
+        if (eventType === 'unlink') {
+            void emit(absPath, 'unlink', null);
+            return;
+        }
+        // Coalesce repeated events for the same path within the debounce window.
+        const existing = queue.get(absPath);
+        if (existing) {
+            existing.coalesced += 1;
+            // Reset the debounce timer.
+            if (existing.timer)
+                clearTimeout(existing.timer);
+            existing.timer = setTimeout(() => { void flush(absPath); }, spec.debounceMs);
+            if (typeof existing.timer.unref === 'function')
+                existing.timer.unref();
+            return;
+        }
+        if (queue.size >= spec.maxQueueDepth) {
+            stats.dropped += 1;
+            if (!stats.overflowed) {
+                stats.overflowed = true;
+                log('warn', `[file-watcher] queue overflow at ${watcherId} — dropping events (depth=${queue.size}, max=${spec.maxQueueDepth})`);
+            }
+            return;
+        }
+        const entry = {
+            absPath,
+            eventType,
+            enqueuedAt: Date.now(),
+            coalesced: 0,
+            timer: null,
+        };
+        entry.timer = setTimeout(() => { void flush(absPath); }, spec.debounceMs);
+        if (entry.timer && typeof entry.timer.unref === 'function')
+            entry.timer.unref();
+        queue.set(absPath, entry);
+        stats.queueDepth = queue.size;
+    };
+    // ── flush + settle + emit ───────────────────────────────────────────────
+    const flush = async (absPath) => {
+        const entry = queue.get(absPath);
+        if (!entry)
+            return;
+        queue.delete(absPath);
+        stats.queueDepth = queue.size;
+        if (stats.overflowed && queue.size <= Math.floor(spec.maxQueueDepth / 2)) {
+            stats.overflowed = false;
+            log('info', `[file-watcher] queue drained at ${watcherId}`);
+        }
+        // Settle: stat repeatedly until stable.
+        const stable = await (0, settleStat_1.settleStat)(absPath, {
+            intervalMs: Math.max(50, spec.settleMs),
+            maxSettleMs: spec.maxSettleMs,
+        });
+        if (stable === null) {
+            // File vanished mid-settle; treat as unlink.
+            void emit(absPath, 'unlink', null, entry.coalesced);
+            return;
+        }
+        void emit(absPath, entry.eventType, stable, entry.coalesced);
+    };
+    const emit = async (absPath, eventType, stable, coalescedDelta = 0) => {
+        try {
+            const fileKey = (0, fsIdentity_1.computeFileKey)(absPath);
+            const size = stable?.size ?? null;
+            const mtimeMs = stable?.mtimeMs ?? Date.now();
+            const contentHash = spec.contentHash && eventType !== 'unlink' && stable !== null
+                ? await sha256OfFile(absPath)
+                : null;
+            const observationId = obsStore.upsert({
+                watcherId,
+                absPath,
+                fileKey,
+                size,
+                mtimeMs,
+                contentHash,
+                eventType,
+                coalescedDelta,
+            });
+            const idempotencyKey = `${absPath}::${mtimeMs}::${size ?? 'null'}`;
+            const insertResult = triggerBus.insert({
+                source: 'file',
+                sourceKey: watcherId,
+                idempotencyKey,
+                payload: {
+                    absPath,
+                    eventType,
+                    mtime: mtimeMs,
+                    size,
+                    fileKey,
+                    contentHash,
+                    watcherId,
+                },
+            });
+            obsStore.markProcessed({
+                observationId,
+                eventId: insertResult.id,
+                status: 'pending',
+            });
+            stats.emitted += 1;
+            stats.coalesced += coalescedDelta;
+        }
+        catch (e) {
+            const msg = e instanceof Error ? e.message : String(e);
+            stats.lastError = msg;
+            log('error', `[file-watcher] emit failed for ${absPath}: ${msg}`);
+        }
+    };
+    // ── wire chokidar events ────────────────────────────────────────────────
+    watcher.on('add', (p) => handleEvent('add', node_path_1.default.resolve(p)));
+    watcher.on('change', (p) => handleEvent('change', node_path_1.default.resolve(p)));
+    watcher.on('unlink', (p) => handleEvent('unlink', node_path_1.default.resolve(p)));
+    watcher.on('error', (err) => {
+        const msg = err instanceof Error ? err.message : String(err);
+        stats.lastError = msg;
+        log('error', `[file-watcher] chokidar error at ${watcherId}: ${msg}`);
+    });
+    // ── resource registry ───────────────────────────────────────────────────
+    const close = async () => {
+        paused = true;
+        // Cancel pending debounce timers.
+        for (const e of queue.values()) {
+            if (e.timer)
+                clearTimeout(e.timer);
+        }
+        queue.clear();
+        stats.queueDepth = 0;
+        try {
+            await watcher.close();
+        }
+        catch (e) {
+            log('warn', `[file-watcher] close error: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    };
+    const resourceId = registry.register({
+        kind: 'file_watcher',
+        owner: watcherId,
+        metadata: { paths: spec.paths },
+        close,
+    });
+    return {
+        watcherId,
+        resourceId,
+        pause() { paused = true; },
+        resume() { paused = false; },
+        close,
+        stats() { return { ...stats }; },
+    };
+}
+// ── SHA-256 of file contents (opt-in via spec.contentHash) ─────────────────
+function sha256OfFile(absPath) {
+    return new Promise((resolve) => {
+        try {
+            const h = node_crypto_1.default.createHash('sha256');
+            const stream = node_fs_1.default.createReadStream(absPath);
+            stream.on('data', (chunk) => { h.update(chunk); });
+            stream.on('error', () => resolve(null));
+            stream.on('end', () => resolve(h.digest('hex')));
+        }
+        catch {
+            resolve(null);
+        }
+    });
+}

package/dist/core/v4/daemon/triggers/fileWatcherSpec.js

@@ -0,0 +1,88 @@
+"use strict";
+/**
+ * Copyright (c) 2026 Shiva Deore (Taracod).
+ * Licensed under AGPL-3.0. See LICENSE for details.
+ *
+ * Aiden — local-first agent.
+ */
+/**
+ * core/v4/daemon/triggers/fileWatcherSpec.ts — v4.5 Phase 2.
+ *
+ * Trigger-spec shape stored in `triggers.spec_json` for
+ * `source='file'`. Pure types + parse helpers; no I/O.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_FILE_WATCHER_SPEC = void 0;
+exports.parseFileWatcherSpec = parseFileWatcherSpec;
+exports.DEFAULT_FILE_WATCHER_SPEC = {
+    recursive: true,
+    eventTypes: ['add', 'change', 'unlink'],
+    debounceMs: 750,
+    settleMs: 1000,
+    maxSettleMs: 30000,
+    maxQueueDepth: 100,
+    ignoreTemp: true,
+    contentHash: false,
+    reconcile: 'skip_existing',
+};
+/**
+ * Parse + fill in defaults. Throws when `paths` is missing/empty.
+ * Tolerates extra keys (forward-compatible).
+ */
+function parseFileWatcherSpec(raw) {
+    const obj = typeof raw === 'string' ? JSON.parse(raw) : raw;
+    if (!obj || typeof obj !== 'object' || Array.isArray(obj)) {
+        throw new Error('FileWatcherSpec: input must be an object');
+    }
+    const o = obj;
+    const paths = Array.isArray(o.paths) ? o.paths.filter((p) => typeof p === 'string') : [];
+    if (paths.length === 0) {
+        throw new Error('FileWatcherSpec: at least one path required');
+    }
+    return {
+        paths,
+        recursive: typeof o.recursive === 'boolean' ? o.recursive : exports.DEFAULT_FILE_WATCHER_SPEC.recursive,
+        includeGlobs: Array.isArray(o.includeGlobs) ? o.includeGlobs.filter((s) => typeof s === 'string') : undefined,
+        excludeGlobs: Array.isArray(o.excludeGlobs) ? o.excludeGlobs.filter((s) => typeof s === 'string') : undefined,
+        eventTypes: sanitizeEventTypes(o.eventTypes),
+        debounceMs: sanitizeNum(o.debounceMs, exports.DEFAULT_FILE_WATCHER_SPEC.debounceMs, 0),
+        settleMs: sanitizeNum(o.settleMs, exports.DEFAULT_FILE_WATCHER_SPEC.settleMs, 0),
+        maxSettleMs: sanitizeNum(o.maxSettleMs, exports.DEFAULT_FILE_WATCHER_SPEC.maxSettleMs, 0),
+        maxQueueDepth: sanitizeNum(o.maxQueueDepth, exports.DEFAULT_FILE_WATCHER_SPEC.maxQueueDepth, 1),
+        ignoreTemp: typeof o.ignoreTemp === 'boolean' ? o.ignoreTemp : exports.DEFAULT_FILE_WATCHER_SPEC.ignoreTemp,
+        contentHash: typeof o.contentHash === 'boolean' ? o.contentHash : exports.DEFAULT_FILE_WATCHER_SPEC.contentHash,
+        reconcile: sanitizeReconcile(o.reconcile),
+        polling: sanitizePolling(o.polling),
+        promptTemplate: typeof o.promptTemplate === 'string' ? o.promptTemplate : undefined,
+    };
+}
+function sanitizeNum(v, fallback, min) {
+    if (typeof v !== 'number' || !Number.isFinite(v) || v < min)
+        return fallback;
+    return v;
+}
+function sanitizeEventTypes(v) {
+    if (!Array.isArray(v))
+        return [...exports.DEFAULT_FILE_WATCHER_SPEC.eventTypes];
+    const valid = new Set(['add', 'change', 'unlink']);
+    const out = v.filter((s) => typeof s === 'string' && valid.has(s));
+    return out.length > 0 ? out : [...exports.DEFAULT_FILE_WATCHER_SPEC.eventTypes];
+}
+function sanitizeReconcile(v) {
+    if (v === 'skip_existing' || v === 'process_new_since_last_seen' || v === 'full_rescan') {
+        return v;
+    }
+    return exports.DEFAULT_FILE_WATCHER_SPEC.reconcile;
+}
+function sanitizePolling(v) {
+    if (!v || typeof v !== 'object' || Array.isArray(v))
+        return undefined;
+    const o = v;
+    if (typeof o.enabled !== 'boolean' || !o.enabled)
+        return undefined;
+    return {
+        enabled: true,
+        intervalMs: typeof o.intervalMs === 'number' && o.intervalMs > 0 ? o.intervalMs : undefined,
+        binaryIntervalMs: typeof o.binaryIntervalMs === 'number' && o.binaryIntervalMs > 0 ? o.binaryIntervalMs : undefined,
+    };
+}

package/dist/core/v4/daemon/triggers/fsIdentity.js

@@ -0,0 +1,42 @@
+"use strict";
+/**
+ * Copyright (c) 2026 Shiva Deore (Taracod).
+ * Licensed under AGPL-3.0. See LICENSE for details.
+ *
+ * Aiden — local-first agent.
+ */
+/**
+ * core/v4/daemon/triggers/fsIdentity.ts — v4.5 Phase 2.
+ *
+ * Compute a best-effort identity key for a file. Used by
+ * `file_observations.file_key` so future v4.5.x revisions can
+ * detect renames-within-watcher without re-scanning the world.
+ *
+ * Platforms:
+ *   - POSIX: ino (inode) — stable across rename
+ *   - Windows: fs.statSync({bigint:true}).ino — packs the NTFS
+ *     file index; stable across rename on the same volume
+ *
+ * Returns '' on stat failure (permission denied, file vanished).
+ * Empty string is acceptable — the (watcher_id, abs_path) UNIQUE
+ * index in file_observations is the primary key; file_key is a
+ * diagnostic/future-feature column.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.computeFileKey = computeFileKey;
+const node_fs_1 = __importDefault(require("node:fs"));
+function computeFileKey(absPath) {
+    try {
+        const st = node_fs_1.default.statSync(absPath, { bigint: true });
+        // BigInt ino — stringify so SQLite stores it as TEXT.
+        if (typeof st.ino === 'bigint')
+            return st.ino.toString();
+        return String(st.ino);
+    }
+    catch {
+        return '';
+    }
+}

package/dist/core/v4/daemon/triggers/globMatcher.js

@@ -0,0 +1,100 @@
+"use strict";
+/**
+ * Copyright (c) 2026 Shiva Deore (Taracod).
+ * Licensed under AGPL-3.0. See LICENSE for details.
+ *
+ * Aiden — local-first agent.
+ */
+/**
+ * core/v4/daemon/triggers/globMatcher.ts — v4.5 Phase 2.
+ *
+ * chokidar 4.x removed built-in glob matching. We use `picomatch`
+ * (already in Aiden's transitive deps) to filter paths AFTER
+ * chokidar emits — same semantics, less bundle weight.
+ *
+ * Match semantics (applied in order):
+ *   1. ignoreTemp default deny list (editor temps, .git/, node_modules/, …)
+ *   2. spec.excludeGlobs deny list
+ *   3. spec.includeGlobs allow list (default ['**∕*'])
+ *
+ * Compiled matchers are cached per-spec so we don't recompile on
+ * every event.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_IGNORE_PATTERNS = void 0;
+exports.normalizeGlobPattern = normalizeGlobPattern;
+exports.compileGlobMatcher = compileGlobMatcher;
+const picomatch_1 = __importDefault(require("picomatch"));
+/** Default ignore patterns when FileWatcherSpec.ignoreTemp = true. */
+exports.DEFAULT_IGNORE_PATTERNS = Object.freeze([
+    // editor temps
+    '**/*.swp', '**/*.swo', '**/*~',
+    '**/.*.swp', '**/.*.swo',
+    '**/*.tmp', '**/*.temp', '**/*.part',
+    '**/.#*', // emacs lock
+    '**/~$*', // MS Office temp
+    // OS metadata
+    '**/.DS_Store', '**/Thumbs.db', '**/desktop.ini',
+    // VCS
+    '**/.git/**', '**/.svn/**', '**/.hg/**',
+    // dependency / build outputs
+    '**/node_modules/**',
+    '**/dist/**', '**/build/**', '**/.next/**',
+    '**/__pycache__/**', '**/*.pyc',
+    '**/.venv/**', '**/venv/**',
+    '**/target/**',
+]);
+/**
+ * Normalize a glob pattern so it matches absolute paths sensibly.
+ *
+ * The user mental model is "`*.txt` matches `.txt` files anywhere",
+ * but picomatch's `*` does NOT span path separators — so a bare
+ * basename glob like `*.txt` never matches `/some/dir/foo.txt`.
+ *
+ * Rule: if a pattern doesn't already begin with double-star,
+ * a leading slash, a Windows drive letter (`C:`), or contain a
+ * `/` directory separator, treat it as a basename pattern and
+ * prepend a depth-spanning prefix so it matches at any depth.
+ * Patterns that already express locality (containing `/` or
+ * starting with double-star) are left alone.
+ */
+function normalizeGlobPattern(pat) {
+    if (pat.startsWith('**'))
+        return pat;
+    if (pat.startsWith('/'))
+        return pat;
+    if (/^[A-Za-z]:/.test(pat))
+        return pat; // absolute Windows path
+    if (pat.includes('/'))
+        return pat;
+    return '**/' + pat;
+}
+function compileGlobMatcher(opts) {
+    const include = opts.includeGlobs && opts.includeGlobs.length > 0
+        ? opts.includeGlobs
+        : ['**/*'];
+    const exclude = [
+        ...(opts.excludeGlobs ?? []),
+        ...(opts.ignoreTemp !== false ? exports.DEFAULT_IGNORE_PATTERNS : []),
+    ];
+    const opt = { dot: true, nocase: process.platform === 'win32' };
+    const compile = (p) => (0, picomatch_1.default)(normalizeGlobPattern(p), opt);
+    const includeFns = include.map(compile);
+    const excludeFns = exclude.map(compile);
+    return {
+        match(absPath) {
+            // Normalize to forward slashes for cross-platform glob matching.
+            const norm = absPath.replace(/\\/g, '/');
+            for (const fn of excludeFns)
+                if (fn(norm))
+                    return false;
+            for (const fn of includeFns)
+                if (fn(norm))
+                    return true;
+            return false;
+        },
+    };
+}

package/dist/core/v4/daemon/triggers/reconcile.js

@@ -0,0 +1,206 @@
+"use strict";
+/**
+ * Copyright (c) 2026 Shiva Deore (Taracod).
+ * Licensed under AGPL-3.0. See LICENSE for details.
+ *
+ * Aiden — local-first agent.
+ */
+/**
+ * core/v4/daemon/triggers/reconcile.ts — v4.5 Phase 2.
+ *
+ * Boot-time reconciliation for file-watcher triggers. Walks the
+ * watched directory trees (glob-pruning excluded dirs) and decides
+ * per-policy whether to emit catch-up events for files that changed
+ * while the daemon was down.
+ *
+ * Three policies (configurable per watcher):
+ *   - `skip_existing` (default) — walk + stat, write observation
+ *     rows with last_status='done' and NO trigger_event emission.
+ *     Future changes after boot emit normally. Matches the IMAP
+ *     `_seen_uids`-on-connect philosophy referenced in the audit.
+ *
+ *   - `process_new_since_last_seen` — for each file, compare its
+ *     current mtime to the existing observation row. If newer (or
+ *     no observation row exists), emit a synthetic 'change' (or
+ *     'add') trigger_event. Catch-up mode.
+ *
+ *   - `full_rescan` — emit a synthetic 'add' for every matched
+ *     file regardless of prior observations. One-shot indexing
+ *     mode — use with care on large trees.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.reconcileFileWatcher = reconcileFileWatcher;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const globMatcher_1 = require("./globMatcher");
+const fsIdentity_1 = require("./fsIdentity");
+const noopLog = (_l, _m) => undefined;
+function reconcileFileWatcher(opts) {
+    const { watcherId, spec, triggerBus, obsStore } = opts;
+    const log = opts.log ?? noopLog;
+    const max = opts.maxEntries ?? 100000;
+    const matcher = (0, globMatcher_1.compileGlobMatcher)({
+        includeGlobs: spec.includeGlobs,
+        excludeGlobs: spec.excludeGlobs,
+        ignoreTemp: spec.ignoreTemp,
+    });
+    const result = {
+        walked: 0, matched: 0, recorded: 0, emitted: 0, skipped: 0,
+    };
+    for (const root of spec.paths) {
+        walkDir(root, spec.recursive, (absPath) => {
+            result.walked += 1;
+            if (result.walked > max)
+                return false;
+            if (!matcher.match(absPath)) {
+                result.skipped += 1;
+                return true;
+            }
+            result.matched += 1;
+            const stat = tryStat(absPath);
+            if (!stat)
+                return true;
+            const prev = obsStore.get(watcherId, absPath);
+            const fileKey = (0, fsIdentity_1.computeFileKey)(absPath);
+            switch (spec.reconcile) {
+                case 'skip_existing': {
+                    // Write observation but do NOT emit a trigger_event.
+                    const obsId = obsStore.upsert({
+                        watcherId,
+                        absPath,
+                        fileKey,
+                        size: stat.size,
+                        mtimeMs: stat.mtimeMs,
+                        contentHash: null,
+                        eventType: 'add',
+                    });
+                    obsStore.markProcessed({
+                        observationId: obsId,
+                        eventId: null,
+                        status: 'done',
+                    });
+                    result.recorded += 1;
+                    break;
+                }
+                case 'process_new_since_last_seen': {
+                    const isNew = !prev;
+                    const isChanged = prev && (prev.mtimeMs !== stat.mtimeMs || prev.size !== stat.size);
+                    if (isNew || isChanged) {
+                        emitFor(opts, watcherId, absPath, isNew ? 'add' : 'change', stat, fileKey);
+                        result.emitted += 1;
+                    }
+                    else {
+                        // Up-to-date — refresh last_seen_at.
+                        obsStore.upsert({
+                            watcherId, absPath, fileKey,
+                            size: stat.size, mtimeMs: stat.mtimeMs,
+                            contentHash: null, eventType: 'change',
+                        });
+                        result.skipped += 1;
+                    }
+                    break;
+                }
+                case 'full_rescan': {
+                    emitFor(opts, watcherId, absPath, 'add', stat, fileKey);
+                    result.emitted += 1;
+                    break;
+                }
+            }
+            return true;
+        }, opts);
+    }
+    log('info', `[file-watcher] reconcile ${spec.reconcile} for ${watcherId}: walked=${result.walked} matched=${result.matched} recorded=${result.recorded} emitted=${result.emitted}`);
+    return result;
+}
+function emitFor(opts, watcherId, absPath, eventType, stat, fileKey) {
+    const obsId = opts.obsStore.upsert({
+        watcherId,
+        absPath,
+        fileKey,
+        size: stat.size,
+        mtimeMs: stat.mtimeMs,
+        contentHash: null,
+        eventType,
+    });
+    const ev = opts.triggerBus.insert({
+        source: 'file',
+        sourceKey: watcherId,
+        idempotencyKey: `${absPath}::${stat.mtimeMs}::${stat.size}`,
+        payload: {
+            absPath,
+            eventType,
+            mtime: stat.mtimeMs,
+            size: stat.size,
+            fileKey,
+            contentHash: null,
+            watcherId,
+            reconciled: true,
+        },
+    });
+    opts.obsStore.markProcessed({
+        observationId: obsId,
+        eventId: ev.id,
+        status: 'pending',
+    });
+}
+function tryStat(p) {
+    try {
+        const s = node_fs_1.default.statSync(p);
+        if (!s.isFile())
+            return null;
+        return { size: s.size, mtimeMs: s.mtimeMs };
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Glob-pruning directory walker. Calls `cb(absPath)` for each FILE
+ * (not directory) encountered. Returning false from the callback
+ * aborts the walk (used for entry caps).
+ *
+ * Dir-level pruning: when a directory's path matches the ignoreTemp/
+ * excludeGlobs patterns, we don't recurse into it — never enumerate
+ * `node_modules/` etc.
+ */
+function walkDir(root, recursive, cb, opts) {
+    const dirMatcher = (0, globMatcher_1.compileGlobMatcher)({
+        excludeGlobs: opts.spec.excludeGlobs,
+        ignoreTemp: opts.spec.ignoreTemp,
+        // Allow EVERYTHING for the directory walker; the exclude list
+        // does the pruning. Include filter is applied per-file via the
+        // caller's matcher.
+        includeGlobs: ['**/*'],
+    });
+    const stack = [node_path_1.default.resolve(root)];
+    while (stack.length > 0) {
+        const dir = stack.pop();
+        let entries;
+        try {
+            entries = node_fs_1.default.readdirSync(dir, { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        for (const ent of entries) {
+            const abs = node_path_1.default.join(dir, ent.name);
+            if (ent.isDirectory()) {
+                // Prune via the *negated* glob match — a directory whose
+                // path does NOT match the exclude/ignoreTemp deny list is
+                // walked into. Since includeGlobs = ['**/*'], a dir matches
+                // iff no exclude/ignore pattern hit it.
+                if (recursive && dirMatcher.match(abs)) {
+                    stack.push(abs);
+                }
+            }
+            else if (ent.isFile()) {
+                const cont = cb(abs);
+                if (!cont)
+                    return;
+            }
+        }
+    }
+}