@getmikk/watcher 1.7.1 → 1.9.0

package/README.md

@@ -1,217 +1,92 @@
-# @getmikk/watcher
+# @getmikk/watcher
 
-> Your architecture map, always in sync — zero manual re-analysis.
+> Live file watcher daemon — incremental, debounced, atomic.
 
 [![npm](https://img.shields.io/npm/v/@getmikk/watcher)](https://www.npmjs.com/package/@getmikk/watcher)
 [![License: Apache-2.0](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](../../LICENSE)
 
-`@getmikk/watcher` keeps `mikk.lock.json` in sync with your source code in real time. It uses Chokidar to watch for file events, batches and debounces changes (so saving 20 files triggers one re-analysis, not twenty), incrementally re-parses only affected files, patches the dependency graph, recomputes Merkle hashes, and writes the lock file atomically — all with a PID-based singleton that prevents duplicate daemon processes.
+Background daemon that keeps `mikk.lock.json` in sync as you edit code. Detects file changes via chokidar, re-parses only what changed, updates the lock atomically, and emits typed events for downstream consumers.
 
-The result: your AI context, impact analysis, and contract validation are always based on the current state of your codebase, not a stale snapshot.
-
-> Part of [Mikk](../../README.md) — the codebase nervous system for AI-assisted development.
+> Part of [Mikk](../../README.md) — live architectural context for your AI agent.
 
 ---
 
-## Installation
+## Usage
+
+Started via the CLI:
 
 ```bash
-npm install @getmikk/watcher
-# or
-bun add @getmikk/watcher
+mikk watch
 ```
 
-**Peer dependency:** `@getmikk/core`
-
----
-
-## Quick Start
+Or programmatically:
 
 ```typescript
 import { WatcherDaemon } from '@getmikk/watcher'
 
 const daemon = new WatcherDaemon({
-  projectRoot: process.cwd(),
-  include: ['src/**/*.ts', 'src/**/*.tsx'],
-  exclude: ['node_modules', 'dist', '.mikk'],
+  projectRoot: '/path/to/project',
+  include: ['**/*.ts', '**/*.tsx'],
+  exclude: ['**/node_modules/**', '**/dist/**'],
   debounceMs: 100,
 })
 
 daemon.on((event) => {
-  switch (event.type) {
-    case 'file:changed':
-      console.log(`Changed: ${event.path}`)
-      break
-    case 'graph:updated':
-      console.log('Dependency graph rebuilt')
-      break
-    case 'sync:clean':
-      console.log('Lock file is in sync')
-      break
-    case 'sync:drifted':
-      console.log('Lock file has drifted')
-      break
+  if (event.type === 'graph:updated') {
+    console.log(`Graph updated: ${event.data.changedNodes.length} changed`)
   }
 })
 
 await daemon.start()
-// Lock file is now kept in sync automatically
-
-// Later...
-await daemon.stop()
-```
-
----
-
-## Architecture
-
-```
-Filesystem Events (Chokidar)
-        │
-        ▼
-  ┌─────────────┐
-  │ FileWatcher  │  ← Hash computation, deduplication
-  └──────┬──────┘
-         │  FileChangeEvent[]
-         ▼
-  ┌──────────────────┐
-  │ WatcherDaemon    │  ← Debouncing (100ms), batching
-  └──────┬───────────┘
-         │  Batch of events
-         ▼
-  ┌─────────────────────┐
-  │ IncrementalAnalyzer  │  ← Re-parse, graph patch, hash update
-  └──────────┬──────────┘
-             │
-             ▼
-    Atomic lock file write
 ```
 
 ---
 
-## API Reference
-
-### WatcherDaemon
-
-The main entry point — a long-running process that keeps the lock file in sync.
-
-```typescript
-import { WatcherDaemon } from '@getmikk/watcher'
-
-const daemon = new WatcherDaemon(config)
-```
-
-**`WatcherConfig`:**
-
-| Field | Type | Default | Description |
-|-------|------|---------|-------------|
-| `projectRoot` | `string` | — | Absolute path to the project |
-| `include` | `string[]` | `['**/*.ts']` | Glob patterns for watched files |
-| `exclude` | `string[]` | `['node_modules']` | Glob patterns to ignore |
-| `debounceMs` | `number` | `100` | Debounce window in milliseconds |
-
-**Methods:**
-
-| Method | Description |
-|--------|-------------|
-| `start()` | Start watching. Creates PID file at `.mikk/watcher.pid` for single-instance enforcement |
-| `stop()` | Stop watching. Cleans up PID file |
-| `on(handler)` | Register event handler |
-
-**Features:**
-
-- **Debouncing** — Batches rapid file changes (e.g., save-all) into a single analysis pass
-- **PID file** — Prevents multiple watcher instances via `.mikk/watcher.pid`
-- **Atomic writes** — Lock file is written atomically to prevent corruption
-- **Sync state** — Emits `sync:clean` or `sync:drifted` after each cycle
-
----
+## How It Works
 
 ### FileWatcher
 
-Lower-level wrapper around Chokidar with hash-based change detection:
+Wraps chokidar. Watches `.ts` and `.tsx` files (configurable). On change:
+1. Computes a SHA-256 hash of the new file content
+2. Compares against the stored hash — skips true no-ops (content unchanged)
+3. Emits a typed `FileChangeEvent` with old hash, new hash, and change type
 
-```typescript
-import { FileWatcher } from '@getmikk/watcher'
+Hash store is seeded at startup from the lock file so first-change dedup works correctly from the beginning.
 
-const watcher = new FileWatcher(config)
-
-watcher.on((event) => {
-  console.log(event.type)       // 'added' | 'changed' | 'deleted'
-  console.log(event.path)       // Absolute file path
-  console.log(event.oldHash)    // Previous content hash (undefined for 'added')
-  console.log(event.newHash)    // New content hash (undefined for 'deleted')
-  console.log(event.timestamp)  // Event timestamp
-  console.log(event.affectedModuleIds) // Modules containing this file
-})
-
-await watcher.start()
-
-// Seed with known hashes to detect only actual content changes
-watcher.setHash('/src/index.ts', 'abc123...')
-
-await watcher.stop()
-```
+### WatcherDaemon
 
-**Hash-based deduplication:** Even if the OS reports a file change, the watcher computes a SHA-256 hash and only emits an event if the content actually changed. This prevents redundant re-analysis from editor auto-saves or format-on-save.
+Orchestrates everything:
 
----
+- **Debounce** — collects file change events for 100ms, then flushes as a batch
+- **Deduplication** — if the same file changes twice in a batch, only the latest event is kept
+- **Batch threshold** — batches under 15 files → incremental analysis; 15+ files → full re-analysis
+- **Atomic writes** — lock file written as temp file then renamed; zero corruption risk on crash
+- **PID file** — `.mikk/watcher.pid` prevents duplicate daemon instances
+- **Sync state** — `.mikk/sync-state.json` tracks `clean | syncing | drifted | conflict`
 
 ### IncrementalAnalyzer
 
-Incrementally updates the dependency graph and lock file for a batch of changed files:
-
-```typescript
-import { IncrementalAnalyzer } from '@getmikk/watcher'
-
-const analyzer = new IncrementalAnalyzer(graph, lock, contract, projectRoot)
-
-const result = await analyzer.analyzeBatch(events)
-
-console.log(result.graph)        // Updated DependencyGraph
-console.log(result.lock)         // Updated MikkLock
-console.log(result.impactResult) // ImpactResult from @getmikk/core
-console.log(result.mode)         // 'incremental' | 'full'
-```
-
-**How it works:**
+Re-parses only changed files, updates graph nodes, and recompiles the lock. O(changed files), not O(whole repo).
 
-1. **Small batches (≤15 files)** → Incremental mode:
-   - Re-parse only changed files
-   - Patch the existing graph (remove old nodes/edges, add new ones)
-   - Recompute affected hashes only
-   - Run impact analysis on changed nodes
+**Race condition handling:** after parsing a file, re-hashes it. If the hash changed during the parse (file was modified while being read), re-parses up to 3 times. Accepts final state after retries are exhausted.
 
-2. **Large batches (>15 files)** → Full re-analysis:
-   - Re-parse all files from scratch
-   - Rebuild entire graph
-   - Recompute all hashes
-
-**Race-condition protection:** After parsing a file, the analyzer re-hashes it. If the hash changed during parsing (the file was modified again), it retries up to 3 times before falling back to the latest parsed version.
+**Full re-analysis path:** triggered when batch size exceeds 15 files (e.g. `git checkout`, bulk rename). Re-parses all changed files in parallel, rebuilds the full graph, recompiles the lock.
 
 ---
 
-### Events
-
-All events emitted through the `on()` handler:
+## Events
 
 ```typescript
 type WatcherEvent =
-  | { type: 'file:changed'; event: FileChangeEvent }
-  | { type: 'module:updated'; moduleId: string }
-  | { type: 'graph:updated'; stats: { nodes: number; edges: number } }
-  | { type: 'sync:clean' }
-  | { type: 'sync:drifted'; driftedModules: string[] }
-```
+  | { type: 'file:changed'; data: FileChangeEvent }
+  | { type: 'graph:updated'; data: { changedNodes: string[]; impactedNodes: string[] } }
+  | { type: 'sync:drifted'; data: { reason: string; affectedModules: string[] } }
 
-**`FileChangeEvent`:**
-
-```typescript
 type FileChangeEvent = {
-  type: 'added' | 'changed' | 'deleted'
-  path: string
-  oldHash?: string
-  newHash?: string
+  type: 'changed' | 'added' | 'deleted'
+  path: string         // relative to project root
+  oldHash: string | null
+  newHash: string | null
   timestamp: number
   affectedModuleIds: string[]
 }
@@ -219,51 +94,15 @@ type FileChangeEvent = {
 
 ---
 
-## Usage with the CLI
-
-The `mikk watch` command starts the watcher daemon:
-
-```bash
-mikk watch
-# Watching src/**/*.ts, src/**/*.tsx...
-# [sync:clean] Lock file is up to date
-# [file:changed] src/auth/login.ts
-# [graph:updated] 142 nodes, 87 edges
-# [sync:clean] Lock file updated
-```
-
-Press `Ctrl+C` to stop.
-
----
-
-## Single-Instance Enforcement
-
-The daemon writes a PID file to `.mikk/watcher.pid` on start and removes it on stop. If another watcher is already running, `start()` will throw an error. This prevents multiple watchers from fighting over the lock file.
-
-```typescript
-try {
-  await daemon.start()
-} catch (err) {
-  if (err.message.includes('already running')) {
-    console.log('Another watcher is already running')
-  }
-}
-```
-
----
-
-## Types
+## Sync State
 
-```typescript
-import type {
-  FileChangeEvent,
-  WatcherConfig,
-  WatcherEvent,
-} from '@getmikk/watcher'
-```
-
----
+Written atomically to `.mikk/sync-state.json` on every transition:
 
-## License
+| Status | Meaning |
+|--------|---------|
+| `clean` | Lock file matches filesystem |
+| `syncing` | Batch in progress |
+| `drifted` | Analysis failed — lock is stale |
+| `conflict` | Manual intervention needed |
 
-[Apache-2.0](../../LICENSE)
+The MCP server reads sync state to surface staleness warnings on every tool call.

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@getmikk/watcher",
-    "version": "1.7.1",
+    "version": "1.9.0",
     "license": "Apache-2.0",
     "repository": {
         "type": "git",
@@ -21,7 +21,7 @@
         "dev": "tsc --watch"
     },
     "dependencies": {
-        "@getmikk/core": "^1.7.1",
+        "@getmikk/core": "^1.9.0",
         "chokidar": "^4.0.0"
     },
     "devDependencies": {

package/src/file-watcher.ts

@@ -4,7 +4,7 @@ import { hashFile } from '@getmikk/core'
 import type { WatcherConfig, WatcherEvent, FileChangeEvent } from './types.js'
 
 /**
- * FileWatcher — wraps Chokidar to watch filesystem for changes.
+ * FileWatcher -- wraps Chokidar to watch filesystem for changes.
  * Computes hash of changed files and emits typed events.
  */
 export class FileWatcher {
@@ -14,12 +14,12 @@ export class FileWatcher {
 
     constructor(private config: WatcherConfig) { }
 
-    /** Start watching — non-blocking */
+    /** Start watching -- non-blocking */
     start(): void {
         const excludesRegexes = this.config.exclude.map(
             pattern => new RegExp(pattern.replace(/\*/g, '.*').replace(/\//g, '[\\\\/]'))
         )
-        const includeExts = ['.ts', '.tsx']
+        const includeExts = ['.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs', '.go']
 
         this.watcher = watch(this.config.projectRoot, {
             ignored: (testPath: string, stats?: import('fs').Stats) => {

package/src/incremental-analyzer.ts

@@ -2,7 +2,7 @@ import * as fs from 'node:fs/promises'
 import * as path from 'node:path'
 import {
     getParser, GraphBuilder, ImpactAnalyzer, LockCompiler, hashFile,
-    type ParsedFile, type DependencyGraph, type MikkLock, type MikkContract, type ImpactResult
+    type ParsedFile, type DependencyGraph, type MikkLock, type MikkContract, type ImpactResult, type GraphEdge
 } from '@getmikk/core'
 import type { FileChangeEvent } from './types.js'
 
@@ -13,14 +13,9 @@ const FULL_ANALYSIS_THRESHOLD = 15
 const MAX_RETRIES = 3
 
 /**
- * IncrementalAnalyzer — re-parses only changed files, updates graph nodes,
- * and recomputes affected module hashes. O(changed files) not O(whole repo).
- *
- * Supports batch analysis: if > 15 files change at once (e.g. git checkout),
- * runs a full re-analysis instead of incremental.
- *
- * Race condition handling: after parsing, re-hashes the file and re-parses
- * if the content changed during parsing (up to 3 retries).
+ * IncrementalAnalyzer — re-parses only changed files, performs a surgical
+ * graph update (removes stale nodes/edges, inserts new ones), then runs
+ * impact analysis over the affected subgraph.
  */
 export class IncrementalAnalyzer {
     private parsedFiles: Map<string, ParsedFile> = new Map()
@@ -30,59 +25,96 @@ export class IncrementalAnalyzer {
         private lock: MikkLock,
         private contract: MikkContract,
         private projectRoot: string
-    ) { }
+    ) {
+        if (!this.graph.outEdges) this.graph.outEdges = new Map()
+        if (!this.graph.inEdges) this.graph.inEdges = new Map()
+    }
 
-    /** Handle a batch of file change events (debounced by daemon) */
+    public get fileCount(): number {
+        return this.parsedFiles.size
+    }
+
+    /** Handle a batch of file change events */
     async analyzeBatch(events: FileChangeEvent[]): Promise<{
         graph: DependencyGraph
         lock: MikkLock
         impactResult: ImpactResult
         mode: 'incremental' | 'full'
     }> {
-        // If too many changes at once, run full analysis
         if (events.length > FULL_ANALYSIS_THRESHOLD) {
             return this.runFullAnalysis(events)
         }
 
-        // Incremental: process each event, collecting changed file paths
         const changedFilePaths: string[] = []
 
         for (const event of events) {
             if (event.type === 'deleted') {
                 this.parsedFiles.delete(event.path)
-                changedFilePaths.push(event.path)
             } else {
                 const parsed = await this.parseWithRaceCheck(event.path)
-                if (parsed) {
-                    this.parsedFiles.set(event.path, parsed)
-                }
-                changedFilePaths.push(event.path)
+                if (parsed) this.parsedFiles.set(event.path, parsed)
             }
+            changedFilePaths.push(event.path)
         }
 
-        // Rebuild graph from all parsed files BEFORE deriving node IDs,
-        // so newly-added files are present in the graph when we look them up.
-        const allParsedFiles = [...this.parsedFiles.values()]
-        const builder = new GraphBuilder()
-        this.graph = builder.build(allParsedFiles)
+        // --- Surgical graph update ---
+        const staleNodeIds = new Set<string>(
+            changedFilePaths.flatMap(fp => this.findNodeIdsForFile(fp))
+        )
+
+        for (const nodeId of staleNodeIds) {
+            this.graph.nodes.delete(nodeId)
+        }
+        for (const fp of changedFilePaths) {
+            this.graph.nodes.delete(fp)
+        }
+
+        const allStaleIds = new Set([...staleNodeIds, ...changedFilePaths])
+        this.graph.edges = this.graph.edges.filter(
+            edge => !allStaleIds.has(edge.from) && !allStaleIds.has(edge.to)
+        )
+
+        const changedParsedFiles = changedFilePaths
+            .map(fp => this.parsedFiles.get(fp))
+            .filter((f): f is ParsedFile => f !== undefined)
+
+        if (changedParsedFiles.length > 0) {
+            const miniBuilder = new GraphBuilder()
+            const miniGraph = miniBuilder.build(changedParsedFiles)
+
+            for (const [id, node] of miniGraph.nodes) {
+                this.graph.nodes.set(id, node)
+            }
+            
+            for (const edge of miniGraph.edges) {
+                 this.graph.edges.push(edge)
+            }
+        }
+
+        // Rebuild adjacency maps
+        this.graph.outEdges = new Map()
+        this.graph.inEdges = new Map()
+        for (const edge of this.graph.edges) {
+            if (!this.graph.outEdges.has(edge.from)) this.graph.outEdges.set(edge.from, [])
+            this.graph.outEdges.get(edge.from)!.push(edge)
+            if (!this.graph.inEdges.has(edge.to)) this.graph.inEdges.set(edge.to, [])
+            this.graph.inEdges.get(edge.to)!.push(edge)
+        }
 
-        // Map changed file paths → graph node IDs using the updated graph
-        const changedNodeIds = [...new Set(
-            changedFilePaths.flatMap(fp => this.findAffectedNodes(fp))
-        )]
+        const changedNodeIds = [
+            ...new Set(changedFilePaths.flatMap(fp => this.findNodeIdsForFile(fp)))
+        ]
 
-        // Run impact analysis on all changed nodes
         const analyzer = new ImpactAnalyzer(this.graph)
         const impactResult = analyzer.analyze(changedNodeIds)
 
-        // Recompile lock
+        const allParsedFiles = [...this.parsedFiles.values()]
         const compiler = new LockCompiler()
-        this.lock = compiler.compile(this.graph, this.contract, allParsedFiles)
+        this.lock = compiler.compile(this.graph, this.contract, allParsedFiles, undefined, this.projectRoot)
 
         return { graph: this.graph, lock: this.lock, impactResult, mode: 'incremental' }
     }
 
-    /** Handle a single file change event */
     async analyze(event: FileChangeEvent): Promise<{
         graph: DependencyGraph
         lock: MikkLock
@@ -92,112 +124,75 @@ export class IncrementalAnalyzer {
         return { graph: result.graph, lock: result.lock, impactResult: result.impactResult }
     }
 
-    /** Add a parsed file to the tracker */
     addParsedFile(file: ParsedFile): void {
         this.parsedFiles.set(file.path, file)
     }
 
-    /** Get the current parsed file count */
-    get fileCount(): number {
-        return this.parsedFiles.size
-    }
-
-    // ─── Private ──────────────────────────────────────────────────
-
-    /**
-     * Parse a file with race-condition detection.
-     * After parsing, re-hash the file. If the hash differs from what we started with,
-     * the file changed during parsing — re-parse (up to MAX_RETRIES).
-     */
     private async parseWithRaceCheck(changedFile: string): Promise<ParsedFile | null> {
         const fullPath = path.join(this.projectRoot, changedFile)
-
         for (let attempt = 0; attempt < MAX_RETRIES; attempt++) {
             try {
                 const content = await fs.readFile(fullPath, 'utf-8')
                 const parser = getParser(changedFile)
-                const parsedFile = parser.parse(changedFile, content)
+                const parsedFile = await parser.parse(changedFile, content)
 
-                // Race condition check: re-hash after parse
                 try {
                     const postParseHash = await hashFile(fullPath)
-                    if (postParseHash === parsedFile.hash) {
-                        return parsedFile // Content stable
-                    }
-                    // Content changed during parse — retry
+                    if (postParseHash === parsedFile.hash) return parsedFile
                 } catch {
-                    return parsedFile // File may have been deleted, return what we have
+                    return parsedFile
                 }
             } catch {
-                return null // File unreadable
+                return null
             }
         }
-
-        // Exhausted retries — parse one final time and accept
-        try {
-            const content = await fs.readFile(fullPath, 'utf-8')
-            const parser = getParser(changedFile)
-            return parser.parse(changedFile, content)
-        } catch {
-            return null
-        }
+        return null
     }
 
-    /** Run a full re-analysis (for large batches like git checkout) */
     private async runFullAnalysis(events: FileChangeEvent[]): Promise<{
         graph: DependencyGraph
         lock: MikkLock
         impactResult: ImpactResult
         mode: 'full'
     }> {
-        // Remove deleted files
         for (const event of events) {
-            if (event.type === 'deleted') {
-                this.parsedFiles.delete(event.path)
-            }
+            if (event.type === 'deleted') this.parsedFiles.delete(event.path)
         }
 
-        // Re-parse all non-deleted changed files
         const nonDeleted = events.filter(e => e.type !== 'deleted')
         await Promise.all(nonDeleted.map(async (event) => {
             const parsed = await this.parseWithRaceCheck(event.path)
-            if (parsed) {
-                this.parsedFiles.set(event.path, parsed)
-            }
+            if (parsed) this.parsedFiles.set(event.path, parsed)
         }))
 
-        // Full rebuild
         const allParsedFiles = [...this.parsedFiles.values()]
         const builder = new GraphBuilder()
         this.graph = builder.build(allParsedFiles)
 
         const compiler = new LockCompiler()
-        this.lock = compiler.compile(this.graph, this.contract, allParsedFiles)
-
-        const changedPaths = events.map(e => e.path)
-
-        return {
-            graph: this.graph,
-            lock: this.lock,
-            impactResult: {
-                changed: changedPaths,
-                impacted: [],
-                classified: {
-                    critical: [],
-                    high: [],
-                    medium: [],
-                    low: [],
-                },
-                depth: 0,
-                confidence: 'low', // Full rebuild = can't determine precise impact
-            },
-            mode: 'full',
+        this.lock = compiler.compile(this.graph, this.contract, allParsedFiles, undefined, this.projectRoot)
+
+        const impactResult: ImpactResult = {
+            changed: events.map(e => e.path),
+            impacted: [],
+            allImpacted: [],
+            depth: 0,
+            entryPoints: [],
+            criticalModules: [],
+            paths: [],
+            confidence: 1.0,
+            riskScore: 0,
+            classified: { critical: [], high: [], medium: [], low: [] }
         }
+
+        return { graph: this.graph, lock: this.lock, impactResult, mode: 'full' }
     }
 
-    private findAffectedNodes(filePath: string): string[] {
-        return [...this.graph.nodes.values()]
-            .filter(n => n.file === filePath)
-            .map(n => n.id)
+    private findNodeIdsForFile(filePath: string): string[] {
+        const ids: string[] = []
+        for (const [id, node] of this.graph.nodes) {
+            if (node.file === filePath) ids.push(id)
+        }
+        return ids
     }
 }

package/tests/analyzer.test.ts

@@ -0,0 +1,158 @@
+import { describe, it, expect } from 'bun:test'
+import { IncrementalAnalyzer } from '../src/incremental-analyzer.js'
+import type { MikkLock, DependencyGraph, MikkContract } from '@getmikk/core'
+import type { FileChangeEvent } from '../src/types.js'
+
+describe('IncrementalAnalyzer', () => {
+    const mockGraph = (): DependencyGraph => ({
+        nodes: new Map(),
+        edges: [],
+        outEdges: new Map(),
+        inEdges: new Map()
+    })
+
+    const mockLock: MikkLock = {
+        version: '2.0.0',
+        generatedAt: new Date().toISOString(),
+        generatorVersion: '1.0.0',
+        projectRoot: '/project',
+        syncState: {
+            status: 'clean',
+            lastSyncAt: new Date().toISOString(),
+            lockHash: 'abc',
+            contractHash: 'xyz'
+        },
+        files: {
+            'src/index.ts': {
+                path: 'src/index.ts',
+                hash: 'abc',
+                moduleId: 'root',
+                lastModified: new Date().toISOString(),
+                imports: []
+            }
+        },
+        functions: {},
+        classes: {},
+        modules: {},
+        graph: {
+            nodes: 1,
+            edges: 0,
+            rootHash: 'abc'
+        }
+    }
+
+    const contract: MikkContract = {
+        version: '2.0.0',
+        project: { 
+            name: 'test', 
+            description: 'test project',
+            language: 'typescript', 
+            framework: 'none',
+            entryPoints: [] 
+        },
+        declared: {
+            modules: [],
+            constraints: [],
+            decisions: []
+        },
+        overwrite: { 
+            mode: 'never', 
+            requireConfirmation: false 
+        },
+        policies: {
+            maxRiskScore: 70,
+            maxImpactNodes: 10,
+            protectedModules: [],
+            enforceStrictBoundaries: true,
+            requireReasoningForCritical: true
+        }
+    }
+
+    it('detects changes correctly without throwing', async () => {
+        const analyzer = new IncrementalAnalyzer(
+            mockGraph(),
+            mockLock,
+            contract,
+            '/project'
+        )
+        
+        const event: FileChangeEvent = { 
+            path: 'src/index.ts', 
+            type: 'changed',
+            oldHash: 'old',
+            newHash: 'abc',
+            timestamp: Date.now(),
+            affectedModuleIds: []
+        }
+        const result = await analyzer.analyze(event)
+        expect(result.graph).toBeDefined()
+        expect(result.lock).toBeDefined()
+        expect(result.impactResult).toBeDefined()
+    })
+
+    describe('Edge Cases and Batch Processing', () => {
+        it('handles file deletions by removing nodes from graph and lock', async () => {
+            const analyzer = new IncrementalAnalyzer(mockGraph(), mockLock, contract, '/project')
+            // First add it
+            analyzer.addParsedFile({ 
+                path: 'src/to-delete.ts', 
+                language: 'typescript', 
+                hash: 'foo', 
+                parsedAt: Date.now(), 
+                functions: [], 
+                classes: [], 
+                imports: [], 
+                exports: [], 
+                routes: [],
+                variables: [],
+                generics: [],
+                calls: []
+            })
+            expect(analyzer.fileCount).toBe(1)
+            
+            // Now send a deleted event
+            const event: FileChangeEvent = { 
+                path: 'src/to-delete.ts', 
+                type: 'deleted',
+                oldHash: 'foo',
+                newHash: '',
+                timestamp: Date.now(),
+                affectedModuleIds: []
+            }
+            await analyzer.analyze(event)
+            expect(analyzer.fileCount).toBe(0)
+        })
+
+        it('survives analyze events on completely non-existent OS files gracefully', async () => {
+            const analyzer = new IncrementalAnalyzer(mockGraph(), mockLock, contract, '/project')
+            const event: FileChangeEvent = { 
+                path: 'does/not/exist.ts', 
+                type: 'changed',
+                oldHash: '',
+                newHash: 'new',
+                timestamp: Date.now(),
+                affectedModuleIds: []
+            }
+            const result = await analyzer.analyzeBatch([event])
+            expect(result.mode).toBe('incremental')
+            expect(result.impactResult).toBeDefined()
+            expect(analyzer.fileCount).toBe(0) 
+        })
+
+        it('triggers a full re-analysis if file batch exceeds FULL_ANALYSIS_THRESHOLD (15)', async () => {
+            const analyzer = new IncrementalAnalyzer(mockGraph(), mockLock, contract, '/project')
+            const events: FileChangeEvent[] = Array.from({ length: 16 }).map((_, i) => ({
+                path: `src/file_${i}.ts`,
+                type: 'changed',
+                oldHash: '',
+                newHash: `hash_${i}`,
+                timestamp: Date.now(),
+                affectedModuleIds: []
+            }))
+            
+            const result = await analyzer.analyzeBatch(events)
+            expect(result.mode).toBe('full')
+            expect(result.impactResult.confidence).toBe(1.0)
+        })
+    })
+})