@vladimir-ks/aigile 0.1.1 → 0.2.1

package/dist/bin/aigile.js

@@ -20,6 +20,284 @@ var __copyProps = (to, from, except, desc) => {
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
+// src/config/monitoring-patterns.ts
+function isBinaryExtension(extension) {
+  const ext = extension.startsWith(".") ? extension.toLowerCase() : `.${extension.toLowerCase()}`;
+  return BINARY_EXTENSIONS.includes(ext);
+}
+function getHardIgnorePatterns() {
+  return [...HARD_IGNORE];
+}
+function getDefaultAllowPatterns() {
+  return [...DEFAULT_ALLOW];
+}
+function getDefaultDenyPatterns() {
+  return [...DEFAULT_DENY];
+}
+var HARD_IGNORE, DEFAULT_ALLOW, DEFAULT_DENY, BINARY_EXTENSIONS;
+var init_monitoring_patterns = __esm({
+  "src/config/monitoring-patterns.ts"() {
+    "use strict";
+    HARD_IGNORE = [
+      // Git directory - internal git data
+      "**/.git/**",
+      // Database files - CRITICAL: prevents infinite sync loops
+      "**/*.db",
+      "**/*.db-journal",
+      "**/*.db-wal",
+      "**/*.db-shm",
+      "**/*.sqlite",
+      "**/*.sqlite3",
+      // Lock and PID files
+      "**/*.pid",
+      "**/*.lock",
+      // OS metadata files
+      "**/.DS_Store",
+      "**/Thumbs.db",
+      "**/.Spotlight-V100/**",
+      "**/.Trashes/**",
+      "**/ehthumbs.db",
+      "**/Desktop.ini"
+    ];
+    DEFAULT_ALLOW = [
+      // Documentation
+      "**/*.md",
+      "**/*.markdown",
+      "**/*.txt",
+      "**/*.rst",
+      "**/*.adoc",
+      // BDD Features
+      "**/*.feature",
+      "**/*.gherkin",
+      // Code - TypeScript/JavaScript
+      "**/*.ts",
+      "**/*.tsx",
+      "**/*.js",
+      "**/*.jsx",
+      "**/*.mjs",
+      "**/*.cjs",
+      // Code - Python
+      "**/*.py",
+      "**/*.pyi",
+      "**/*.pyx",
+      // Code - Go
+      "**/*.go",
+      "**/*.mod",
+      "**/*.sum",
+      // Code - Rust
+      "**/*.rs",
+      // Code - Java/JVM
+      "**/*.java",
+      "**/*.kt",
+      "**/*.kts",
+      "**/*.scala",
+      "**/*.groovy",
+      // Code - C/C++
+      "**/*.c",
+      "**/*.cpp",
+      "**/*.cc",
+      "**/*.cxx",
+      "**/*.h",
+      "**/*.hpp",
+      "**/*.hxx",
+      // Code - Ruby
+      "**/*.rb",
+      "**/*.rake",
+      "**/Rakefile",
+      "**/Gemfile",
+      // Code - PHP
+      "**/*.php",
+      // Code - Shell
+      "**/*.sh",
+      "**/*.bash",
+      "**/*.zsh",
+      "**/*.fish",
+      // Config - YAML
+      "**/*.yaml",
+      "**/*.yml",
+      // Config - JSON
+      "**/*.json",
+      "**/*.jsonc",
+      "**/*.json5",
+      // Config - TOML
+      "**/*.toml",
+      // Config - XML
+      "**/*.xml",
+      "**/*.xsd",
+      "**/*.xsl",
+      "**/*.xslt",
+      "**/*.plist",
+      // Config - INI/ENV
+      "**/*.ini",
+      "**/*.env",
+      "**/*.env.*",
+      "**/*.properties",
+      "**/*.cfg",
+      "**/*.conf",
+      // Data formats
+      "**/*.csv",
+      "**/*.tsv",
+      "**/*.sql",
+      "**/*.graphql",
+      "**/*.gql",
+      // Web templates
+      "**/*.html",
+      "**/*.htm",
+      "**/*.css",
+      "**/*.scss",
+      "**/*.sass",
+      "**/*.less",
+      "**/*.vue",
+      "**/*.svelte",
+      // Build files
+      "**/Dockerfile",
+      "**/Dockerfile.*",
+      "**/docker-compose.yml",
+      "**/docker-compose.yaml",
+      "**/docker-compose.*.yml",
+      "**/docker-compose.*.yaml",
+      "**/Makefile",
+      "**/CMakeLists.txt",
+      // Package manifests
+      "**/package.json",
+      "**/tsconfig.json",
+      "**/tsconfig.*.json",
+      "**/jsconfig.json",
+      "**/pyproject.toml",
+      "**/setup.py",
+      "**/setup.cfg",
+      "**/requirements.txt",
+      "**/requirements-*.txt",
+      "**/Cargo.toml",
+      "**/Cargo.lock",
+      "**/go.mod",
+      "**/go.sum",
+      "**/pom.xml",
+      "**/build.gradle",
+      "**/settings.gradle"
+    ];
+    DEFAULT_DENY = [
+      // Package managers
+      "**/node_modules/**",
+      "**/bower_components/**",
+      "**/vendor/**",
+      "**/.pnpm-store/**",
+      "**/pnpm-lock.yaml",
+      "**/package-lock.json",
+      "**/yarn.lock",
+      // Build output
+      "**/dist/**",
+      "**/build/**",
+      "**/out/**",
+      "**/target/**",
+      "**/__pycache__/**",
+      "**/*.pyc",
+      "**/*.pyo",
+      "**/*.class",
+      "**/*.o",
+      "**/*.obj",
+      "**/*.so",
+      "**/*.dll",
+      "**/*.dylib",
+      "**/*.exe",
+      // Test coverage
+      "**/coverage/**",
+      "**/.nyc_output/**",
+      "**/.coverage/**",
+      "**/htmlcov/**",
+      // IDE/Editor
+      "**/.idea/**",
+      "**/.vscode/**",
+      "**/.vs/**",
+      "**/*.swp",
+      "**/*.swo",
+      "**/*~",
+      "**/.*.swp",
+      // Temp files
+      "**/*.tmp",
+      "**/*.temp",
+      "**/*.bak",
+      "**/*.backup",
+      "**/*.old",
+      // Log files
+      "**/*.log",
+      "**/logs/**",
+      "**/npm-debug.log*",
+      "**/yarn-debug.log*",
+      "**/yarn-error.log*",
+      // Cache
+      "**/.cache/**",
+      "**/.parcel-cache/**",
+      "**/.next/**",
+      "**/.nuxt/**",
+      "**/.turbo/**",
+      // Environment
+      "**/.env.local",
+      "**/.env.*.local",
+      // Misc
+      "**/.terraform/**",
+      "**/terraform.tfstate*"
+    ];
+    BINARY_EXTENSIONS = [
+      // Images
+      ".png",
+      ".jpg",
+      ".jpeg",
+      ".gif",
+      ".bmp",
+      ".ico",
+      ".svg",
+      ".webp",
+      ".tiff",
+      ".tif",
+      ".psd",
+      ".ai",
+      // Documents
+      ".pdf",
+      ".doc",
+      ".docx",
+      ".xls",
+      ".xlsx",
+      ".ppt",
+      ".pptx",
+      ".odt",
+      ".ods",
+      ".odp",
+      // Archives
+      ".zip",
+      ".tar",
+      ".gz",
+      ".bz2",
+      ".xz",
+      ".7z",
+      ".rar",
+      // Audio
+      ".mp3",
+      ".wav",
+      ".ogg",
+      ".flac",
+      ".aac",
+      ".m4a",
+      // Video
+      ".mp4",
+      ".webm",
+      ".mkv",
+      ".avi",
+      ".mov",
+      ".wmv",
+      // Fonts
+      ".ttf",
+      ".otf",
+      ".woff",
+      ".woff2",
+      ".eot",
+      // Compiled
+      ".wasm",
+      ".node"
+    ];
+  }
+});
+
 // src/utils/config.ts
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
 import { homedir } from "os";
@@ -68,9 +346,61 @@ function findProjectRoot(startPath = process.cwd()) {
   }
   return null;
 }
+function parseIgnoreFile(filePath) {
+  try {
+    const content = readFileSync(filePath, "utf-8");
+    const patterns = [];
+    for (let line of content.split("\n")) {
+      line = line.trim();
+      if (!line || line.startsWith("#")) {
+        continue;
+      }
+      if (line.startsWith("!")) {
+        continue;
+      }
+      let pattern = line;
+      if (pattern.startsWith("/")) {
+        pattern = pattern.slice(1);
+      }
+      if (!pattern.startsWith("**/") && !pattern.includes("/")) {
+        pattern = `**/${pattern}`;
+      }
+      if (pattern.endsWith("/")) {
+        pattern = pattern.slice(0, -1) + "/**";
+      }
+      patterns.push(pattern);
+    }
+    return patterns;
+  } catch {
+    return [];
+  }
+}
+function loadIgnorePatterns(projectPath) {
+  const ignorePath = join(projectPath, ".aigile", "ignore");
+  if (!existsSync(ignorePath)) {
+    return getDefaultDenyPatterns();
+  }
+  const patterns = parseIgnoreFile(ignorePath);
+  return patterns.length > 0 ? patterns : getDefaultDenyPatterns();
+}
+function loadAllowPatterns(projectPath) {
+  const config = loadProjectConfig(projectPath);
+  if (!config) {
+    return getDefaultAllowPatterns();
+  }
+  const extendedConfig = config;
+  if (extendedConfig.sync?.allow_patterns && extendedConfig.sync.allow_patterns.length > 0) {
+    return extendedConfig.sync.allow_patterns;
+  }
+  if (config.sync?.patterns && config.sync.patterns.length > 0) {
+    return config.sync.patterns;
+  }
+  return getDefaultAllowPatterns();
+}
 var init_config = __esm({
   "src/utils/config.ts"() {
     "use strict";
+    init_monitoring_patterns();
   }
 });
 
@@ -91,6 +421,7 @@ __export(connection_exports, {
 import initSqlJs from "sql.js";
 import { existsSync as existsSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2, mkdirSync as mkdirSync2 } from "fs";
 import { dirname } from "path";
+import { randomUUID } from "crypto";
 async function initDatabase() {
   if (db) {
     return db;
@@ -121,9 +452,13 @@ function getDatabase() {
 }
 function saveDatabase() {
   if (db && dbPath) {
-    const data2 = db.export();
-    const buffer = Buffer.from(data2);
-    writeFileSync2(dbPath, buffer);
+    try {
+      const data2 = db.export();
+      const buffer = Buffer.from(data2);
+      writeFileSync2(dbPath, buffer);
+    } catch (err) {
+      console.error(`[${(/* @__PURE__ */ new Date()).toISOString()}] Database save error: ${err}`);
+    }
   }
 }
 function closeDatabase() {
@@ -383,6 +718,16 @@ function initializeSchema(database) {
       meta_authors TEXT,
       has_frontmatter INTEGER DEFAULT 0,
       frontmatter_raw TEXT,
+      -- Shadow mode analysis fields
+      shadow_mode INTEGER DEFAULT 0,
+      analyzed_at TEXT,
+      analysis_confidence INTEGER,
+      file_type TEXT,
+      complexity_score INTEGER,
+      exports TEXT,
+      inferred_module TEXT,
+      inferred_component TEXT,
+      analysis_notes TEXT,
       created_at TEXT DEFAULT (datetime('now')),
       updated_at TEXT DEFAULT (datetime('now')),
       UNIQUE(project_id, path)
@@ -446,7 +791,7 @@ function initializeSchema(database) {
   `);
 }
 function generateId() {
-  return crypto.randomUUID();
+  return randomUUID();
 }
 function getNextKey(projectKey) {
   const row = queryOne(
@@ -483,7 +828,21 @@ function runMigrations() {
     { name: "meta_code_refs", type: "TEXT" },
     { name: "meta_authors", type: "TEXT" },
     { name: "has_frontmatter", type: "INTEGER DEFAULT 0" },
-    { name: "frontmatter_raw", type: "TEXT" }
+    { name: "frontmatter_raw", type: "TEXT" },
+    // Shadow mode analysis columns
+    { name: "shadow_mode", type: "INTEGER DEFAULT 0" },
+    { name: "analyzed_at", type: "TEXT" },
+    { name: "analysis_confidence", type: "INTEGER" },
+    { name: "file_type", type: "TEXT" },
+    { name: "complexity_score", type: "INTEGER" },
+    { name: "exports", type: "TEXT" },
+    { name: "inferred_module", type: "TEXT" },
+    { name: "inferred_component", type: "TEXT" },
+    { name: "analysis_notes", type: "TEXT" },
+    // Tri-state monitoring columns
+    { name: "monitoring_category", type: 'TEXT DEFAULT "unknown"' },
+    { name: "needs_review", type: "INTEGER DEFAULT 0" },
+    { name: "reviewed_at", type: "TEXT" }
   ];
   for (const col of newColumns) {
     if (!columnNames.has(col.name)) {
@@ -493,6 +852,31 @@ function runMigrations() {
       }
     }
   }
+  database.run(`
+    CREATE TABLE IF NOT EXISTS sessions (
+      id TEXT PRIMARY KEY,
+      project_id TEXT REFERENCES projects(id),
+      started_at TEXT DEFAULT (datetime('now')),
+      ended_at TEXT,
+      summary TEXT,
+      entities_modified INTEGER DEFAULT 0,
+      files_modified INTEGER DEFAULT 0,
+      status TEXT DEFAULT 'active'
+    )
+  `);
+  database.run(`
+    CREATE TABLE IF NOT EXISTS activity_log (
+      id TEXT PRIMARY KEY,
+      session_id TEXT REFERENCES sessions(id),
+      project_id TEXT REFERENCES projects(id),
+      entity_type TEXT NOT NULL,
+      entity_key TEXT NOT NULL,
+      action TEXT NOT NULL,
+      old_value TEXT,
+      new_value TEXT,
+      timestamp TEXT DEFAULT (datetime('now'))
+    )
+  `);
   saveDatabase();
 }
 var db, dbPath;
@@ -506,10 +890,10 @@ var init_connection = __esm({
 });
 
 // src/bin/aigile.ts
-import { Command as Command21 } from "commander";
+import { Command as Command22 } from "commander";
 
 // src/index.ts
-var VERSION = "0.1.0";
+var VERSION = "0.2.1";
 
 // src/bin/aigile.ts
 init_connection();
@@ -1651,8 +2035,13 @@ function updateGitignore(repoPath, opts) {
 // src/commands/project.ts
 init_connection();
 import { Command as Command2 } from "commander";
+import { existsSync as existsSync5 } from "fs";
+import { join as join5 } from "path";
+function isValidProject(path) {
+  return existsSync5(path) && existsSync5(join5(path, ".aigile"));
+}
 var projectCommand = new Command2("project").description("Manage registered projects");
-projectCommand.command("list").alias("ls").description("List all registered projects").action(() => {
+projectCommand.command("list").alias("ls").description("List all registered projects with validity status").action(() => {
   const opts = getOutputOptions(projectCommand);
   const projects = queryAll(`
       SELECT key, name, path, is_default,
@@ -1668,23 +2057,48 @@ projectCommand.command("list").alias("ls").description("List all registered proj
     }
     return;
   }
-  const formattedProjects = projects.map((p) => ({
-    key: p.is_default ? `${p.key} *` : p.key,
-    name: p.name,
-    path: p.path
-  }));
+  const formattedProjects = projects.map((p) => {
+    const valid = isValidProject(p.path);
+    return {
+      status: valid ? "\u2713" : "\u2717",
+      key: p.is_default ? `${p.key} *` : p.key,
+      name: p.name,
+      path: p.path,
+      valid
+      // For JSON output
+    };
+  });
+  const invalidCount = formattedProjects.filter((p) => !p.valid).length;
+  if (opts.json) {
+    console.log(JSON.stringify({
+      success: true,
+      data: formattedProjects.map((p) => ({
+        key: p.key.replace(" *", ""),
+        name: p.name,
+        path: p.path,
+        valid: p.valid,
+        is_default: p.key.includes("*")
+      })),
+      invalidCount
+    }));
+    return;
+  }
   data(
     formattedProjects,
     [
+      { header: "", key: "status", width: 3 },
       { header: "Key", key: "key", width: 12 },
       { header: "Name", key: "name", width: 30 },
       { header: "Path", key: "path", width: 50 }
     ],
     opts
   );
-  if (!opts.json) {
+  blank();
+  console.log("  * = default project");
+  console.log("  \u2713 = valid path, \u2717 = missing/invalid path");
+  if (invalidCount > 0) {
     blank();
-    console.log("  * = default project");
+    warning(`${invalidCount} project(s) have invalid paths. Run "aigile project cleanup" to remove.`, opts);
   }
 });
 projectCommand.command("show").argument("[key]", "Project key (uses default if not specified)").description("Show project details").action((key) => {
@@ -1722,16 +2136,105 @@ projectCommand.command("set-default").argument("<key>", "Project key to set as d
   run("UPDATE projects SET is_default = 1 WHERE key = ?", [key]);
   success(`Default project set to "${key}".`, opts);
 });
-projectCommand.command("remove").alias("rm").argument("<key>", "Project key to remove").option("--force", "Remove without confirmation").description("Remove project from registry (does not delete files)").action((key, options) => {
+projectCommand.command("remove").alias("rm").argument("<key>", "Project key to remove").option("--cascade", "Also delete all entities (epics, stories, tasks, etc.)").option("--force", "Remove without confirmation").description("Remove project from registry (does not delete files)").action((key, options) => {
   const opts = getOutputOptions(projectCommand);
-  const project = queryOne("SELECT id FROM projects WHERE key = ?", [key]);
+  const project = queryOne(
+    "SELECT id, name, path FROM projects WHERE key = ?",
+    [key]
+  );
   if (!project) {
     error(`Project "${key}" not found.`, opts);
     process.exit(1);
   }
+  if (options.cascade) {
+    const tables = [
+      "documents",
+      "doc_comments",
+      "tasks",
+      "bugs",
+      "user_stories",
+      "epics",
+      "initiatives",
+      "sprints",
+      "components",
+      "versions",
+      "personas",
+      "ux_journeys",
+      "sessions",
+      "activity_log",
+      "key_sequences"
+    ];
+    for (const table of tables) {
+      try {
+        run(`DELETE FROM ${table} WHERE project_id = ?`, [project.id]);
+      } catch {
+      }
+    }
+    info(`Deleted all entities for project "${key}".`, opts);
+  }
   run("DELETE FROM projects WHERE key = ?", [key]);
   success(`Project "${key}" removed from registry.`, opts);
 });
+projectCommand.command("cleanup").description("Remove all projects with invalid/missing paths").option("--dry-run", "Show what would be removed without removing").option("--cascade", "Also delete all entities for removed projects").action((options) => {
+  const opts = getOutputOptions(projectCommand);
+  const projects = queryAll("SELECT id, key, name, path FROM projects");
+  const invalidProjects = projects.filter((p) => !isValidProject(p.path));
+  if (invalidProjects.length === 0) {
+    success("All projects have valid paths. Nothing to clean up.", opts);
+    return;
+  }
+  if (opts.json) {
+    console.log(JSON.stringify({
+      success: true,
+      dryRun: options.dryRun ?? false,
+      invalidProjects: invalidProjects.map((p) => ({
+        key: p.key,
+        name: p.name,
+        path: p.path
+      }))
+    }));
+    if (options.dryRun) {
+      return;
+    }
+  }
+  if (options.dryRun) {
+    info(`Would remove ${invalidProjects.length} invalid project(s):`, opts);
+    for (const p of invalidProjects) {
+      console.log(`  - ${p.key}: ${p.path}`);
+    }
+    return;
+  }
+  for (const project of invalidProjects) {
+    if (options.cascade) {
+      const tables = [
+        "documents",
+        "doc_comments",
+        "tasks",
+        "bugs",
+        "user_stories",
+        "epics",
+        "initiatives",
+        "sprints",
+        "components",
+        "versions",
+        "personas",
+        "ux_journeys",
+        "sessions",
+        "activity_log",
+        "key_sequences"
+      ];
+      for (const table of tables) {
+        try {
+          run(`DELETE FROM ${table} WHERE project_id = ?`, [project.id]);
+        } catch {
+        }
+      }
+    }
+    run("DELETE FROM projects WHERE id = ?", [project.id]);
+    info(`Removed: ${project.key} (${project.path})`, opts);
+  }
+  success(`Cleaned up ${invalidProjects.length} invalid project(s).`, opts);
+});
 
 // src/commands/epic.ts
 init_connection();
@@ -2551,8 +3054,90 @@ bugCommand.command("delete").alias("rm").argument("<key>", "Bug key").option("--
 init_connection();
 import { Command as Command7 } from "commander";
 init_config();
+
+// src/utils/date.ts
+var DATE_FORMAT = "YYYY-MM-DD";
+function isValidDateFormat(dateStr) {
+  if (!dateStr) return false;
+  const regex = /^\d{4}-\d{2}-\d{2}$/;
+  if (!regex.test(dateStr)) {
+    return false;
+  }
+  const [year, month, day] = dateStr.split("-").map(Number);
+  if (month < 1 || month > 12) {
+    return false;
+  }
+  const daysInMonth = new Date(year, month, 0).getDate();
+  if (day < 1 || day > daysInMonth) {
+    return false;
+  }
+  return true;
+}
+function parseDate(dateStr) {
+  if (!dateStr || typeof dateStr !== "string") {
+    return null;
+  }
+  const trimmed = dateStr.trim();
+  if (/^\d{4}-\d{2}-\d{2}$/.test(trimmed)) {
+    return isValidDateFormat(trimmed) ? trimmed : null;
+  }
+  if (/^\d{4}-\d{2}-\d{2}T/.test(trimmed)) {
+    const datePart = trimmed.split("T")[0];
+    return isValidDateFormat(datePart) ? datePart : null;
+  }
+  const slashYMD = trimmed.match(/^(\d{4})\/(\d{2})\/(\d{2})$/);
+  if (slashYMD) {
+    const result = `${slashYMD[1]}-${slashYMD[2]}-${slashYMD[3]}`;
+    return isValidDateFormat(result) ? result : null;
+  }
+  const slashMDY = trimmed.match(/^(\d{1,2})\/(\d{1,2})\/(\d{4})$/);
+  if (slashMDY) {
+    let [, first, second, year] = slashMDY;
+    const firstNum = Number(first);
+    const secondNum = Number(second);
+    let month, day;
+    if (firstNum > 12) {
+      day = first.padStart(2, "0");
+      month = second.padStart(2, "0");
+    } else {
+      month = first.padStart(2, "0");
+      day = second.padStart(2, "0");
+    }
+    const result = `${year}-${month}-${day}`;
+    return isValidDateFormat(result) ? result : null;
+  }
+  const dotDMY = trimmed.match(/^(\d{1,2})\.(\d{1,2})\.(\d{4})$/);
+  if (dotDMY) {
+    const [, day, month, year] = dotDMY;
+    const result = `${year}-${month.padStart(2, "0")}-${day.padStart(2, "0")}`;
+    return isValidDateFormat(result) ? result : null;
+  }
+  const parsed = new Date(trimmed);
+  if (!isNaN(parsed.getTime())) {
+    const year = parsed.getFullYear();
+    const month = String(parsed.getMonth() + 1).padStart(2, "0");
+    const day = String(parsed.getDate()).padStart(2, "0");
+    const result = `${year}-${month}-${day}`;
+    return isValidDateFormat(result) ? result : null;
+  }
+  return null;
+}
+function validateAndStandardizeDate(dateStr, fieldName) {
+  const standardized = parseDate(dateStr);
+  if (!standardized) {
+    throw new Error(
+      `Invalid date format for ${fieldName}: "${dateStr}". Expected format: ${DATE_FORMAT} (e.g., 2025-12-14)`
+    );
+  }
+  return standardized;
+}
+function isEndDateValid(startDate, endDate) {
+  return endDate >= startDate;
+}
+
+// src/commands/sprint.ts
 var sprintCommand = new Command7("sprint").description("Manage sprints");
-sprintCommand.command("create").argument("<name>", "Sprint name").requiredOption("--start <date>", "Start date (YYYY-MM-DD)").requiredOption("--end <date>", "End date (YYYY-MM-DD)").option("-g, --goal <goal>", "Sprint goal").description("Create a new sprint").action((name, options) => {
+sprintCommand.command("create").argument("<name>", "Sprint name").requiredOption("--start <date>", `Start date (${DATE_FORMAT})`).requiredOption("--end <date>", `End date (${DATE_FORMAT})`).option("-g, --goal <goal>", "Sprint goal").description("Create a new sprint").action((name, options) => {
   const opts = getOutputOptions(sprintCommand);
   const projectRoot = findProjectRoot();
   if (!projectRoot) {
@@ -2569,16 +3154,29 @@ sprintCommand.command("create").argument("<name>", "Sprint name").requiredOption
     error(`Project "${config.project.key}" not found.`, opts);
     process.exit(1);
   }
+  let startDate;
+  let endDate;
+  try {
+    startDate = validateAndStandardizeDate(options.start, "start date");
+    endDate = validateAndStandardizeDate(options.end, "end date");
+  } catch (err) {
+    error(err instanceof Error ? err.message : String(err), opts);
+    process.exit(1);
+  }
+  if (!isEndDateValid(startDate, endDate)) {
+    error(`End date (${endDate}) must be after start date (${startDate}).`, opts);
+    process.exit(1);
+  }
   const sprintId = generateId();
   run(
     `INSERT INTO sprints (id, project_id, name, goal, start_date, end_date, status)
        VALUES (?, ?, ?, ?, ?, ?, 'future')`,
-    [sprintId, project.id, name, options.goal ?? null, options.start, options.end]
+    [sprintId, project.id, name, options.goal ?? null, startDate, endDate]
   );
   if (opts.json) {
-    console.log(JSON.stringify({ success: true, data: { name, start: options.start, end: options.end } }));
+    console.log(JSON.stringify({ success: true, data: { name, start: startDate, end: endDate } }));
   } else {
-    success(`Created sprint "${name}" (${options.start} - ${options.end})`, opts);
+    success(`Created sprint "${name}" (${startDate} - ${endDate})`, opts);
   }
 });
 sprintCommand.command("list").alias("ls").option("-s, --status <status>", "Filter by status (future/active/closed)").description("List sprints").action((options) => {
@@ -2813,7 +3411,7 @@ init_connection();
 import { Command as Command9 } from "commander";
 init_config();
 var initiativeCommand = new Command9("initiative").description("Manage initiatives (portfolio-level objectives)");
-initiativeCommand.command("create").argument("<summary>", "Initiative summary").option("-d, --description <description>", "Initiative description").option("-p, --priority <priority>", "Priority (Highest/High/Medium/Low/Lowest)", "Medium").option("--owner <owner>", "Owner").option("--start <date>", "Start date (YYYY-MM-DD)").option("--target <date>", "Target date (YYYY-MM-DD)").description("Create a new initiative").action((summary, options) => {
+initiativeCommand.command("create").argument("<summary>", "Initiative summary").option("-d, --description <description>", "Initiative description").option("-p, --priority <priority>", "Priority (Highest/High/Medium/Low/Lowest)", "Medium").option("--owner <owner>", "Owner").option("--start <date>", `Start date (${DATE_FORMAT})`).option("--target <date>", `Target date (${DATE_FORMAT})`).description("Create a new initiative").action((summary, options) => {
   const opts = getOutputOptions(initiativeCommand);
   const projectRoot = findProjectRoot();
   if (!projectRoot) {
@@ -2830,6 +3428,23 @@ initiativeCommand.command("create").argument("<summary>", "Initiative summary").
     error(`Project "${config.project.key}" not found in database.`, opts);
     process.exit(1);
   }
+  let startDate = null;
+  let targetDate = null;
+  try {
+    if (options.start) {
+      startDate = validateAndStandardizeDate(options.start, "start date");
+    }
+    if (options.target) {
+      targetDate = validateAndStandardizeDate(options.target, "target date");
+    }
+  } catch (err) {
+    error(err instanceof Error ? err.message : String(err), opts);
+    process.exit(1);
+  }
+  if (startDate && targetDate && !isEndDateValid(startDate, targetDate)) {
+    error(`Target date (${targetDate}) must be after start date (${startDate}).`, opts);
+    process.exit(1);
+  }
   const initiativeId = generateId();
   const initiativeKey = getNextKey(config.project.key);
   run(
@@ -2843,8 +3458,8 @@ initiativeCommand.command("create").argument("<summary>", "Initiative summary").
       options.description ?? null,
       options.priority,
       options.owner ?? null,
-      options.start ?? null,
-      options.target ?? null
+      startDate,
+      targetDate
     ]
   );
   if (opts.json) {
@@ -2919,9 +3534,12 @@ initiativeCommand.command("show").argument("<key>", "Initiative key").descriptio
     opts
   );
 });
-initiativeCommand.command("update").argument("<key>", "Initiative key").option("-s, --summary <summary>", "New summary").option("-d, --description <description>", "New description").option("-p, --priority <priority>", "New priority").option("--owner <owner>", "New owner").option("--start <date>", "New start date").option("--target <date>", "New target date").description("Update initiative").action((key, options) => {
+initiativeCommand.command("update").argument("<key>", "Initiative key").option("-s, --summary <summary>", "New summary").option("-d, --description <description>", "New description").option("-p, --priority <priority>", "New priority").option("--owner <owner>", "New owner").option("--start <date>", `New start date (${DATE_FORMAT})`).option("--target <date>", `New target date (${DATE_FORMAT})`).description("Update initiative").action((key, options) => {
   const opts = getOutputOptions(initiativeCommand);
-  const initiative = queryOne("SELECT id FROM initiatives WHERE key = ?", [key]);
+  const initiative = queryOne(
+    "SELECT id, start_date, target_date FROM initiatives WHERE key = ?",
+    [key]
+  );
   if (!initiative) {
     error(`Initiative "${key}" not found.`, opts);
     process.exit(1);
@@ -2944,13 +3562,28 @@ initiativeCommand.command("update").argument("<key>", "Initiative key").option("
     updates.push("owner = ?");
     params.push(options.owner);
   }
-  if (options.start) {
-    updates.push("start_date = ?");
-    params.push(options.start);
+  let startDate = null;
+  let targetDate = null;
+  try {
+    if (options.start) {
+      startDate = validateAndStandardizeDate(options.start, "start date");
+      updates.push("start_date = ?");
+      params.push(startDate);
+    }
+    if (options.target) {
+      targetDate = validateAndStandardizeDate(options.target, "target date");
+      updates.push("target_date = ?");
+      params.push(targetDate);
+    }
+  } catch (err) {
+    error(err instanceof Error ? err.message : String(err), opts);
+    process.exit(1);
   }
-  if (options.target) {
-    updates.push("target_date = ?");
-    params.push(options.target);
+  const effectiveStart = startDate ?? initiative.start_date;
+  const effectiveTarget = targetDate ?? initiative.target_date;
+  if (effectiveStart && effectiveTarget && !isEndDateValid(effectiveStart, effectiveTarget)) {
+    error(`Target date (${effectiveTarget}) must be after start date (${effectiveStart}).`, opts);
+    process.exit(1);
   }
   if (updates.length === 0) {
     error("No updates specified.", opts);
@@ -2991,14 +3624,14 @@ initiativeCommand.command("delete").alias("rm").argument("<key>", "Initiative ke
 // src/commands/sync.ts
 init_connection();
 import { Command as Command10 } from "commander";
-import { join as join6 } from "path";
+import { join as join7 } from "path";
 init_config();
 
 // src/services/file-scanner.ts
 init_connection();
 import { createHash } from "crypto";
-import { readFileSync as readFileSync5, statSync, readdirSync, existsSync as existsSync5 } from "fs";
-import { join as join5, relative as relative2, extname } from "path";
+import { readFileSync as readFileSync5, statSync, readdirSync, existsSync as existsSync6 } from "fs";
+import { join as join6, relative as relative2, extname } from "path";
 
 // src/services/frontmatter-parser.ts
 import { readFileSync as readFileSync4 } from "fs";
@@ -3128,57 +3761,79 @@ function updateFrontmatterContent(content, updates) {
 }
 
 // src/services/file-scanner.ts
-var DEFAULT_PATTERNS = ["**/*.md", "**/*.feature", "**/*.yaml", "**/*.yml"];
-var DEFAULT_IGNORE = ["node_modules", ".git", "dist", "coverage", ".aigile"];
+init_monitoring_patterns();
+init_config();
+import picomatch from "picomatch";
 function computeFileHash(filePath) {
   const content = readFileSync5(filePath);
   return createHash("sha256").update(content).digest("hex");
 }
-function shouldIgnore(relativePath, ignorePatterns) {
-  for (const pattern of ignorePatterns) {
-    if (relativePath.includes(pattern) || relativePath.startsWith(pattern)) {
-      return true;
-    }
+var FileClassifier = class {
+  hardIgnoreMatcher;
+  allowMatcher;
+  denyMatcher;
+  constructor(allowPatterns, denyPatterns) {
+    this.hardIgnoreMatcher = picomatch(getHardIgnorePatterns());
+    this.allowMatcher = picomatch(allowPatterns);
+    this.denyMatcher = picomatch(denyPatterns);
   }
-  return false;
-}
-function matchesPattern(filename, patterns) {
-  const ext = extname(filename).toLowerCase();
-  for (const pattern of patterns) {
-    if (pattern.includes("*.")) {
-      const patternExt = "." + pattern.split("*.").pop();
-      if (ext === patternExt) {
-        return true;
-      }
+  /**
+   * Classify a file into allow/deny/unknown category
+   */
+  classify(relativePath) {
+    if (this.hardIgnoreMatcher(relativePath)) {
+      return "deny";
     }
-    if (pattern === filename) {
-      return true;
+    if (this.allowMatcher(relativePath)) {
+      return "allow";
     }
+    if (this.denyMatcher(relativePath)) {
+      return "deny";
+    }
+    return "unknown";
   }
-  return false;
-}
-function collectFiles(dir, rootDir, patterns, ignore, files = []) {
-  if (!existsSync5(dir)) {
+  /**
+   * Check if file should be completely skipped (hard ignore)
+   */
+  isHardIgnored(relativePath) {
+    return this.hardIgnoreMatcher(relativePath);
+  }
+};
+function collectFiles(dir, rootDir, classifier, trackUnknown, files = []) {
+  if (!existsSync6(dir)) {
     return files;
   }
   const entries = readdirSync(dir, { withFileTypes: true });
   for (const entry of entries) {
-    const fullPath = join5(dir, entry.name);
+    const fullPath = join6(dir, entry.name);
     const relativePath = relative2(rootDir, fullPath);
-    if (shouldIgnore(relativePath, ignore)) {
+    if (classifier.isHardIgnored(relativePath)) {
       continue;
     }
     if (entry.isDirectory()) {
-      collectFiles(fullPath, rootDir, patterns, ignore, files);
-    } else if (entry.isFile() && matchesPattern(entry.name, patterns)) {
+      const dirCategory = classifier.classify(relativePath + "/");
+      if (dirCategory === "deny") {
+        continue;
+      }
+      collectFiles(fullPath, rootDir, classifier, trackUnknown, files);
+    } else if (entry.isFile()) {
+      const category = classifier.classify(relativePath);
+      if (category === "deny") {
+        continue;
+      }
+      if (category === "unknown" && !trackUnknown) {
+        continue;
+      }
       try {
         const stats = statSync(fullPath);
-        const hash = computeFileHash(fullPath);
+        const ext = extname(entry.name).toLowerCase().slice(1);
+        const isBinary = isBinaryExtension(ext);
+        const shouldComputeHash = category === "allow" || !isBinary && stats.size < 10 * 1024 * 1024;
+        const hash = shouldComputeHash ? computeFileHash(fullPath) : null;
         let hasFrontmatter = false;
         let frontmatterRaw;
         let metadata;
-        const ext = extname(entry.name).toLowerCase();
-        if (ext === ".md" || ext === ".markdown") {
+        if (category === "allow" && (ext === "md" || ext === "markdown") && !isBinary) {
           const parsed = parseFrontmatterFromFile(fullPath);
           if (parsed) {
             hasFrontmatter = true;
@@ -3189,12 +3844,14 @@ function collectFiles(dir, rootDir, patterns, ignore, files = []) {
         files.push({
           path: relativePath,
           filename: entry.name,
-          extension: ext.slice(1),
+          extension: ext,
           size: stats.size,
           hash,
           hasFrontmatter,
           frontmatterRaw,
-          metadata
+          metadata,
+          category,
+          isBinary
         });
       } catch {
       }
@@ -3203,9 +3860,13 @@ function collectFiles(dir, rootDir, patterns, ignore, files = []) {
   return files;
 }
 function scanDirectory(projectPath, options = {}) {
-  const patterns = options.patterns ?? DEFAULT_PATTERNS;
-  const ignore = options.ignore ?? DEFAULT_IGNORE;
-  return collectFiles(projectPath, projectPath, patterns, ignore);
+  const allowPatterns = options.patterns ?? loadAllowPatterns(projectPath);
+  const denyPatterns = options.ignore ?? loadIgnorePatterns(projectPath);
+  const trackUnknown = options.trackUnknown ?? true;
+  const finalAllowPatterns = allowPatterns.length > 0 ? allowPatterns : getDefaultAllowPatterns();
+  const finalDenyPatterns = denyPatterns.length > 0 ? denyPatterns : getDefaultDenyPatterns();
+  const classifier = new FileClassifier(finalAllowPatterns, finalDenyPatterns);
+  return collectFiles(projectPath, projectPath, classifier, trackUnknown);
 }
 function syncFilesToDatabase(projectId, projectPath, files) {
   const result = {
@@ -3228,13 +3889,15 @@ function syncFilesToDatabase(projectId, projectPath, files) {
     const metaDependencies = file.metadata?.dependencies ? JSON.stringify(file.metadata.dependencies) : null;
     const metaCodeRefs = file.metadata?.code_refs ? JSON.stringify(file.metadata.code_refs) : null;
     const metaAuthors = file.metadata?.authors ? JSON.stringify(file.metadata.authors) : null;
+    const needsReview = file.category === "unknown" ? 1 : 0;
     if (!existing) {
       run(
         `INSERT INTO documents (
           id, project_id, path, filename, extension, content_hash, size_bytes, status, last_scanned_at,
           has_frontmatter, frontmatter_raw, meta_status, meta_version, meta_tldr, meta_title,
-          meta_modules, meta_dependencies, meta_code_refs, meta_authors
-        ) VALUES (?, ?, ?, ?, ?, ?, ?, 'tracked', ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+          meta_modules, meta_dependencies, meta_code_refs, meta_authors,
+          monitoring_category, needs_review
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, 'tracked', ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
         [
           generateId(),
           projectId,
@@ -3253,7 +3916,9 @@ function syncFilesToDatabase(projectId, projectPath, files) {
           metaModules,
           metaDependencies,
           metaCodeRefs,
-          metaAuthors
+          metaAuthors,
+          file.category,
+          needsReview
         ]
       );
       result.new++;
@@ -3262,7 +3927,8 @@ function syncFilesToDatabase(projectId, projectPath, files) {
         `UPDATE documents SET
           content_hash = ?, size_bytes = ?, status = 'modified', last_scanned_at = ?, updated_at = datetime('now'),
           has_frontmatter = ?, frontmatter_raw = ?, meta_status = ?, meta_version = ?, meta_tldr = ?, meta_title = ?,
-          meta_modules = ?, meta_dependencies = ?, meta_code_refs = ?, meta_authors = ?
+          meta_modules = ?, meta_dependencies = ?, meta_code_refs = ?, meta_authors = ?,
+          monitoring_category = ?
          WHERE id = ?`,
         [
           file.hash,
@@ -3278,14 +3944,15 @@ function syncFilesToDatabase(projectId, projectPath, files) {
           metaDependencies,
           metaCodeRefs,
           metaAuthors,
+          file.category,
           existing.id
         ]
       );
       result.modified++;
     } else {
       run(
-        `UPDATE documents SET last_scanned_at = ?, status = 'tracked' WHERE id = ?`,
-        [now, existing.id]
+        `UPDATE documents SET last_scanned_at = ?, status = 'tracked', monitoring_category = ? WHERE id = ?`,
+        [now, file.category, existing.id]
       );
       result.unchanged++;
     }
@@ -3315,6 +3982,14 @@ function getSyncStatus(projectId) {
     FROM documents
     WHERE project_id = ?
   `, [projectId]);
+  const categoryStats = queryOne(`
+    SELECT
+      SUM(CASE WHEN monitoring_category = 'allow' THEN 1 ELSE 0 END) as allow,
+      SUM(CASE WHEN monitoring_category = 'deny' THEN 1 ELSE 0 END) as deny,
+      SUM(CASE WHEN monitoring_category = 'unknown' OR monitoring_category IS NULL THEN 1 ELSE 0 END) as unknown
+    FROM documents
+    WHERE project_id = ?
+  `, [projectId]);
   const lastScan = queryOne(
     "SELECT MAX(last_scanned_at) as last_scanned_at FROM documents WHERE project_id = ?",
     [projectId]
@@ -3324,7 +3999,12 @@ function getSyncStatus(projectId) {
     tracked: stats?.tracked ?? 0,
     modified: stats?.modified ?? 0,
     deleted: stats?.deleted ?? 0,
-    lastScan: lastScan?.last_scanned_at ?? null
+    lastScan: lastScan?.last_scanned_at ?? null,
+    byCategory: {
+      allow: categoryStats?.allow ?? 0,
+      deny: categoryStats?.deny ?? 0,
+      unknown: categoryStats?.unknown ?? 0
+    }
   };
 }
 function getDocuments(projectId, status) {
@@ -3417,65 +4097,306 @@ function searchDocumentsByTldr(projectId, searchTerm) {
     [projectId, `%${searchTerm}%`]
   );
 }
-
-// src/services/comment-parser.ts
-init_connection();
-import { readFileSync as readFileSync6 } from "fs";
-var USER_COMMENT_PATTERN = /\[\[!\s*([\s\S]*?)\s*\]\]/g;
-var AI_COMMENT_PATTERN = /\[\{!\s*([\s\S]*?)\s*\}]/g;
-function parseComments(filePath) {
-  const content = readFileSync6(filePath, "utf-8");
-  const lines = content.split("\n");
-  const comments = [];
-  const positionToLine = [];
-  let pos = 0;
-  for (let lineNum = 0; lineNum < lines.length; lineNum++) {
-    const lineLength = lines[lineNum].length + 1;
-    for (let i = 0; i < lineLength; i++) {
-      positionToLine[pos++] = lineNum + 1;
-    }
+function getUnanalyzedDocuments(projectId, limit, offset) {
+  let query = `
+    SELECT id, path, filename, extension, status, size_bytes, last_scanned_at,
+           has_frontmatter, meta_status, meta_version, meta_tldr, meta_title,
+           meta_modules, meta_dependencies, meta_code_refs, meta_authors,
+           shadow_mode, analyzed_at, analysis_confidence, file_type,
+           complexity_score, exports, inferred_module, inferred_component, analysis_notes
+    FROM documents
+    WHERE project_id = ? AND analyzed_at IS NULL AND status != 'deleted'
+    ORDER BY path
+  `;
+  const params = [projectId];
+  if (limit !== void 0) {
+    query += " LIMIT ?";
+    params.push(limit);
   }
-  let match;
-  USER_COMMENT_PATTERN.lastIndex = 0;
-  while ((match = USER_COMMENT_PATTERN.exec(content)) !== null) {
-    comments.push({
-      type: "user",
-      content: match[1].trim(),
-      lineNumber: positionToLine[match.index] ?? 1,
-      raw: match[0]
-    });
+  if (offset !== void 0) {
+    query += " OFFSET ?";
+    params.push(offset);
   }
-  AI_COMMENT_PATTERN.lastIndex = 0;
-  while ((match = AI_COMMENT_PATTERN.exec(content)) !== null) {
-    comments.push({
-      type: "ai",
-      content: match[1].trim(),
-      lineNumber: positionToLine[match.index] ?? 1,
-      raw: match[0]
-    });
+  return queryAll(query, params);
+}
+function getUnanalyzedCount(projectId) {
+  const result = queryOne(
+    `SELECT COUNT(*) as count FROM documents
+     WHERE project_id = ? AND analyzed_at IS NULL AND status != 'deleted'`,
+    [projectId]
+  );
+  return result?.count ?? 0;
+}
+function getAnalyzedDocuments(projectId, limit) {
+  let query = `
+    SELECT id, path, filename, extension, status, size_bytes, last_scanned_at,
+           has_frontmatter, meta_status, meta_version, meta_tldr, meta_title,
+           meta_modules, meta_dependencies, meta_code_refs, meta_authors,
+           shadow_mode, analyzed_at, analysis_confidence, file_type,
+           complexity_score, exports, inferred_module, inferred_component, analysis_notes
+    FROM documents
+    WHERE project_id = ? AND analyzed_at IS NOT NULL AND status != 'deleted'
+    ORDER BY analyzed_at DESC
+  `;
+  const params = [projectId];
+  if (limit !== void 0) {
+    query += " LIMIT ?";
+    params.push(limit);
   }
-  comments.sort((a, b) => a.lineNumber - b.lineNumber);
-  return comments;
+  return queryAll(query, params);
 }
-function syncCommentsToDatabase(documentId, comments) {
-  const result = {
-    total: comments.length,
-    new: 0,
-    resolved: 0
-  };
-  const existingComments = queryAll(
-    "SELECT id, marker_type, line_number, content FROM doc_comments WHERE document_id = ? AND resolved = 0",
-    [documentId]
+function getLowConfidenceDocuments(projectId, threshold = 70) {
+  return queryAll(
+    `SELECT id, path, filename, extension, status, size_bytes, last_scanned_at,
+            has_frontmatter, meta_status, meta_version, meta_tldr, meta_title,
+            meta_modules, meta_dependencies, meta_code_refs, meta_authors,
+            shadow_mode, analyzed_at, analysis_confidence, file_type,
+            complexity_score, exports, inferred_module, inferred_component, analysis_notes
+     FROM documents
+     WHERE project_id = ? AND analyzed_at IS NOT NULL
+       AND analysis_confidence IS NOT NULL AND analysis_confidence < ?
+       AND status != 'deleted'
+     ORDER BY analysis_confidence ASC`,
+    [projectId, threshold]
   );
-  const processedIds = /* @__PURE__ */ new Set();
-  for (const comment of comments) {
-    const markerType = comment.type === "user" ? "user" : "ai";
-    const existing = existingComments.find(
-      (e) => e.marker_type === markerType && e.content === comment.content
-    );
-    if (existing) {
-      processedIds.add(existing.id);
-      if (existing.line_number !== comment.lineNumber) {
+}
+function getDocumentsByInferredModule(projectId, module) {
+  return queryAll(
+    `SELECT id, path, filename, extension, status, size_bytes, last_scanned_at,
+            has_frontmatter, meta_status, meta_version, meta_tldr, meta_title,
+            meta_modules, meta_dependencies, meta_code_refs, meta_authors,
+            shadow_mode, analyzed_at, analysis_confidence, file_type,
+            complexity_score, exports, inferred_module, inferred_component, analysis_notes
+     FROM documents
+     WHERE project_id = ? AND inferred_module = ? AND status != 'deleted'
+     ORDER BY path`,
+    [projectId, module]
+  );
+}
+function getDocumentsByFileType(projectId, fileType) {
+  return queryAll(
+    `SELECT id, path, filename, extension, status, size_bytes, last_scanned_at,
+            has_frontmatter, meta_status, meta_version, meta_tldr, meta_title,
+            meta_modules, meta_dependencies, meta_code_refs, meta_authors,
+            shadow_mode, analyzed_at, analysis_confidence, file_type,
+            complexity_score, exports, inferred_module, inferred_component, analysis_notes
+     FROM documents
+     WHERE project_id = ? AND file_type = ? AND status != 'deleted'
+     ORDER BY path`,
+    [projectId, fileType]
+  );
+}
+function getDocumentWithAnalysis(projectId, filePath) {
+  return queryOne(
+    `SELECT id, path, filename, extension, status, size_bytes, last_scanned_at,
+            has_frontmatter, meta_status, meta_version, meta_tldr, meta_title,
+            meta_modules, meta_dependencies, meta_code_refs, meta_authors,
+            shadow_mode, analyzed_at, analysis_confidence, file_type,
+            complexity_score, exports, inferred_module, inferred_component, analysis_notes
+     FROM documents
+     WHERE project_id = ? AND path = ?`,
+    [projectId, filePath]
+  );
+}
+function updateDocumentAnalysis(projectId, filePath, analysis) {
+  const doc = getDocumentByPath(projectId, filePath);
+  if (!doc) {
+    return false;
+  }
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const deps = analysis.dependencies ? JSON.stringify(analysis.dependencies) : null;
+  const exps = analysis.exports ? JSON.stringify(analysis.exports) : null;
+  run(
+    `UPDATE documents SET
+       meta_tldr = COALESCE(?, meta_tldr),
+       meta_dependencies = COALESCE(?, meta_dependencies),
+       inferred_module = COALESCE(?, inferred_module),
+       inferred_component = COALESCE(?, inferred_component),
+       file_type = COALESCE(?, file_type),
+       exports = COALESCE(?, exports),
+       complexity_score = COALESCE(?, complexity_score),
+       analysis_confidence = COALESCE(?, analysis_confidence),
+       analysis_notes = COALESCE(?, analysis_notes),
+       analyzed_at = ?,
+       updated_at = datetime('now')
+     WHERE id = ?`,
+    [
+      analysis.tldr ?? null,
+      deps,
+      analysis.module ?? null,
+      analysis.component ?? null,
+      analysis.fileType ?? null,
+      exps,
+      analysis.complexity ?? null,
+      analysis.confidence ?? null,
+      analysis.notes ?? null,
+      now,
+      doc.id
+    ]
+  );
+  return true;
+}
+function getAnalysisProgress(projectId) {
+  const counts = queryOne(`
+    SELECT
+      COUNT(*) as total,
+      SUM(CASE WHEN analyzed_at IS NOT NULL THEN 1 ELSE 0 END) as analyzed,
+      SUM(CASE WHEN analyzed_at IS NULL THEN 1 ELSE 0 END) as unanalyzed,
+      SUM(CASE WHEN analysis_confidence IS NOT NULL AND analysis_confidence < 70 THEN 1 ELSE 0 END) as low_confidence
+    FROM documents
+    WHERE project_id = ? AND status != 'deleted'
+  `, [projectId]);
+  const moduleStats = queryAll(`
+    SELECT
+      COALESCE(inferred_module, 'unknown') as module,
+      SUM(CASE WHEN analyzed_at IS NOT NULL THEN 1 ELSE 0 END) as analyzed,
+      COUNT(*) as total
+    FROM documents
+    WHERE project_id = ? AND status != 'deleted'
+    GROUP BY COALESCE(inferred_module, 'unknown')
+    ORDER BY total DESC
+  `, [projectId]);
+  const typeStats = queryAll(`
+    SELECT
+      COALESCE(file_type, extension, 'unknown') as file_type,
+      COUNT(*) as count
+    FROM documents
+    WHERE project_id = ? AND status != 'deleted'
+    GROUP BY COALESCE(file_type, extension, 'unknown')
+    ORDER BY count DESC
+  `, [projectId]);
+  const byModule = {};
+  for (const stat of moduleStats) {
+    byModule[stat.module ?? "unknown"] = {
+      analyzed: stat.analyzed,
+      total: stat.total
+    };
+  }
+  const byFileType = {};
+  for (const stat of typeStats) {
+    byFileType[stat.file_type ?? "unknown"] = stat.count;
+  }
+  return {
+    total: counts?.total ?? 0,
+    analyzed: counts?.analyzed ?? 0,
+    unanalyzed: counts?.unanalyzed ?? 0,
+    lowConfidence: counts?.low_confidence ?? 0,
+    byModule,
+    byFileType
+  };
+}
+function getShadowDocuments(projectId) {
+  return queryAll(
+    `SELECT id, path, filename, extension, status, size_bytes, last_scanned_at,
+            has_frontmatter, meta_status, meta_version, meta_tldr, meta_title,
+            meta_modules, meta_dependencies, meta_code_refs, meta_authors,
+            shadow_mode, analyzed_at, analysis_confidence, file_type,
+            complexity_score, exports, inferred_module, inferred_component, analysis_notes
+     FROM documents
+     WHERE project_id = ? AND shadow_mode = 1 AND status != 'deleted'
+     ORDER BY path`,
+    [projectId]
+  );
+}
+function markAsShadowMode(projectId, filePath) {
+  const doc = getDocumentByPath(projectId, filePath);
+  if (!doc) {
+    return false;
+  }
+  run(
+    `UPDATE documents SET shadow_mode = 1, updated_at = datetime('now') WHERE id = ?`,
+    [doc.id]
+  );
+  return true;
+}
+function trackShadowFile(projectId, projectPath, filePath) {
+  const fullPath = join6(projectPath, filePath);
+  if (!existsSync6(fullPath)) {
+    return null;
+  }
+  const existing = getDocumentByPath(projectId, filePath);
+  if (existing) {
+    markAsShadowMode(projectId, filePath);
+    return getDocumentWithAnalysis(projectId, filePath) ?? null;
+  }
+  try {
+    const stats = statSync(fullPath);
+    const hash = computeFileHash(fullPath);
+    const filename = filePath.split("/").pop() ?? filePath;
+    const ext = extname(filename).slice(1);
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const id = generateId();
+    run(
+      `INSERT INTO documents (
+        id, project_id, path, filename, extension, content_hash, size_bytes,
+        status, last_scanned_at, shadow_mode, has_frontmatter
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, 'tracked', ?, 1, 0)`,
+      [id, projectId, filePath, filename, ext, hash, stats.size, now]
+    );
+    return getDocumentWithAnalysis(projectId, filePath) ?? null;
+  } catch {
+    return null;
+  }
+}
+
+// src/services/comment-parser.ts
+init_connection();
+import { readFileSync as readFileSync6 } from "fs";
+var USER_COMMENT_PATTERN = /\[\[!\s*([\s\S]*?)\s*\]\]/g;
+var AI_COMMENT_PATTERN = /\[\{!\s*([\s\S]*?)\s*\}]/g;
+function parseComments(filePath) {
+  const content = readFileSync6(filePath, "utf-8");
+  const lines = content.split("\n");
+  const comments = [];
+  const positionToLine = [];
+  let pos = 0;
+  for (let lineNum = 0; lineNum < lines.length; lineNum++) {
+    const lineLength = lines[lineNum].length + 1;
+    for (let i = 0; i < lineLength; i++) {
+      positionToLine[pos++] = lineNum + 1;
+    }
+  }
+  let match;
+  USER_COMMENT_PATTERN.lastIndex = 0;
+  while ((match = USER_COMMENT_PATTERN.exec(content)) !== null) {
+    comments.push({
+      type: "user",
+      content: match[1].trim(),
+      lineNumber: positionToLine[match.index] ?? 1,
+      raw: match[0]
+    });
+  }
+  AI_COMMENT_PATTERN.lastIndex = 0;
+  while ((match = AI_COMMENT_PATTERN.exec(content)) !== null) {
+    comments.push({
+      type: "ai",
+      content: match[1].trim(),
+      lineNumber: positionToLine[match.index] ?? 1,
+      raw: match[0]
+    });
+  }
+  comments.sort((a, b) => a.lineNumber - b.lineNumber);
+  return comments;
+}
+function syncCommentsToDatabase(documentId, comments) {
+  const result = {
+    total: comments.length,
+    new: 0,
+    resolved: 0
+  };
+  const existingComments = queryAll(
+    "SELECT id, marker_type, line_number, content FROM doc_comments WHERE document_id = ? AND resolved = 0",
+    [documentId]
+  );
+  const processedIds = /* @__PURE__ */ new Set();
+  for (const comment of comments) {
+    const markerType = comment.type === "user" ? "user" : "ai";
+    const existing = existingComments.find(
+      (e) => e.marker_type === markerType && e.content === comment.content
+    );
+    if (existing) {
+      processedIds.add(existing.id);
+      if (existing.line_number !== comment.lineNumber) {
         run(
           "UPDATE doc_comments SET line_number = ? WHERE id = ?",
           [comment.lineNumber, existing.id]
@@ -3519,7 +4440,7 @@ function getCommentStats(projectId) {
 
 // src/commands/sync.ts
 var syncCommand = new Command10("sync").description("File synchronization and document tracking");
-syncCommand.command("scan").option("--patterns <patterns>", 'Comma-separated glob patterns (e.g., "**/*.md,**/*.feature")').option("--ignore <dirs>", "Comma-separated directories to ignore").option("--comments", "Also parse and sync comments from files").description("Scan repository files and sync to database").action((options) => {
+syncCommand.command("scan").option("--patterns <patterns>", 'Comma-separated glob patterns (e.g., "**/*.md,**/*.feature")').option("--ignore <dirs>", "Comma-separated directories to ignore").option("--comments", "Also parse and sync comments from files").option("--shadow", "Shadow mode: track files without modifying them (for brownfield projects)").option("--track-all", "Track all source files, not just docs (use with --shadow)").option("--include <patterns>", 'Additional patterns to include (e.g., "**/*.ts,**/*.js")').option("--exclude <patterns>", "Additional patterns to exclude").description("Scan repository files and sync to database").action((options) => {
   const opts = getOutputOptions(syncCommand);
   const projectRoot = findProjectRoot();
   if (!projectRoot) {
@@ -3537,12 +4458,47 @@ syncCommand.command("scan").option("--patterns <patterns>", 'Comma-separated glo
     process.exit(1);
   }
   const scanOptions = {};
+  if (options.trackAll) {
+    scanOptions.patterns = [
+      "**/*.md",
+      "**/*.feature",
+      "**/*.yaml",
+      "**/*.yml",
+      "**/*.ts",
+      "**/*.tsx",
+      "**/*.js",
+      "**/*.jsx",
+      "**/*.py",
+      "**/*.go",
+      "**/*.rs",
+      "**/*.java",
+      "**/*.css",
+      "**/*.scss",
+      "**/*.less",
+      "**/*.json",
+      "**/*.toml",
+      "**/*.sql",
+      "**/*.graphql"
+    ];
+  }
   if (options.patterns) {
     scanOptions.patterns = options.patterns.split(",").map((p) => p.trim());
   }
+  if (options.include) {
+    const includePatterns = options.include.split(",").map((p) => p.trim());
+    scanOptions.patterns = [...scanOptions.patterns ?? [], ...includePatterns];
+  }
   if (options.ignore) {
     scanOptions.ignore = options.ignore.split(",").map((d) => d.trim());
   }
+  if (options.exclude) {
+    const excludePatterns = options.exclude.split(",").map((d) => d.trim());
+    scanOptions.ignore = [...scanOptions.ignore ?? [], ...excludePatterns];
+  }
+  const isShadowMode = options.shadow || options.trackAll;
+  if (isShadowMode) {
+    info("Shadow mode: tracking files without modification", opts);
+  }
   info("Scanning files...", opts);
   const files = scanDirectory(projectRoot, scanOptions);
   const result = syncFilesToDatabase(project.id, projectRoot, files);
@@ -3552,7 +4508,7 @@ syncCommand.command("scan").option("--patterns <patterns>", 'Comma-separated glo
     for (const file of files) {
       if (["md", "feature", "yaml", "yml"].includes(file.extension)) {
         try {
-          const fullPath = join6(projectRoot, file.path);
+          const fullPath = join7(projectRoot, file.path);
           const comments = parseComments(fullPath);
           const doc = queryOne(
             "SELECT id FROM documents WHERE project_id = ? AND path = ?",
@@ -3568,10 +4524,16 @@ syncCommand.command("scan").option("--patterns <patterns>", 'Comma-separated glo
       }
     }
   }
+  const fileTypeBreakdown = {};
+  for (const file of files) {
+    const ext = file.extension || "other";
+    fileTypeBreakdown[ext] = (fileTypeBreakdown[ext] || 0) + 1;
+  }
   if (opts.json) {
     console.log(JSON.stringify({
       success: true,
       data: {
+        shadowMode: isShadowMode,
         files: {
           total: result.total,
           new: result.new,
@@ -3579,6 +4541,7 @@ syncCommand.command("scan").option("--patterns <patterns>", 'Comma-separated glo
           deleted: result.deleted,
           unchanged: result.unchanged
         },
+        breakdown: isShadowMode ? fileTypeBreakdown : void 0,
         comments: options.comments ? commentStats : void 0
       }
     }));
@@ -3591,6 +4554,12 @@ syncCommand.command("scan").option("--patterns <patterns>", 'Comma-separated glo
     if (options.comments) {
       console.log(`  Comments:  ${commentStats.new} new, ${commentStats.resolved} resolved`);
     }
+    if (isShadowMode && Object.keys(fileTypeBreakdown).length > 0) {
+      console.log("\n  File types:");
+      for (const [ext, count] of Object.entries(fileTypeBreakdown).sort((a, b) => b[1] - a[1]).slice(0, 10)) {
+        console.log(`    .${ext}: ${count}`);
+      }
+    }
   }
 });
 syncCommand.command("status").description("Show file sync status").action(() => {
@@ -6162,7 +7131,7 @@ init_connection();
 import { Command as Command16 } from "commander";
 init_config();
 var versionCommand = new Command16("version").description("Manage project versions/releases");
-versionCommand.command("create").argument("<name>", "Version name (e.g., v1.0.0)").option("-d, --description <description>", "Version description").option("--start <date>", "Start date (YYYY-MM-DD)").option("--release <date>", "Release date (YYYY-MM-DD)").description("Create a new version").action((name, options) => {
+versionCommand.command("create").argument("<name>", "Version name (e.g., v1.0.0)").option("-d, --description <description>", "Version description").option("--start <date>", `Start date (${DATE_FORMAT})`).option("--release <date>", `Release date (${DATE_FORMAT})`).description("Create a new version").action((name, options) => {
   const opts = getOutputOptions(versionCommand);
   const projectRoot = findProjectRoot();
   if (!projectRoot) {
@@ -6184,11 +7153,28 @@ versionCommand.command("create").argument("<name>", "Version name (e.g., v1.0.0)
     error(`Version "${name}" already exists.`, opts);
     process.exit(1);
   }
+  let startDate = null;
+  let releaseDate = null;
+  try {
+    if (options.start) {
+      startDate = validateAndStandardizeDate(options.start, "start date");
+    }
+    if (options.release) {
+      releaseDate = validateAndStandardizeDate(options.release, "release date");
+    }
+  } catch (err) {
+    error(err instanceof Error ? err.message : String(err), opts);
+    process.exit(1);
+  }
+  if (startDate && releaseDate && !isEndDateValid(startDate, releaseDate)) {
+    error(`Release date (${releaseDate}) must be after start date (${startDate}).`, opts);
+    process.exit(1);
+  }
   const versionId = generateId();
   run(
     `INSERT INTO versions (id, project_id, name, description, status, start_date, release_date)
        VALUES (?, ?, ?, ?, 'unreleased', ?, ?)`,
-    [versionId, project.id, name, options.description ?? null, options.start ?? null, options.release ?? null]
+    [versionId, project.id, name, options.description ?? null, startDate, releaseDate]
   );
   logCreate(project.id, "version", versionId, { name, description: options.description });
   if (opts.json) {
@@ -6276,7 +7262,7 @@ versionCommand.command("show").argument("<name>", "Version name").description("S
     opts
   );
 });
-versionCommand.command("update").argument("<name>", "Version name").option("-d, --description <description>", "Version description").option("--start <date>", "Start date (YYYY-MM-DD)").option("--release <date>", "Release date (YYYY-MM-DD)").option("--rename <newName>", "Rename version").description("Update a version").action((name, options) => {
+versionCommand.command("update").argument("<name>", "Version name").option("-d, --description <description>", "Version description").option("--start <date>", `Start date (${DATE_FORMAT})`).option("--release <date>", `Release date (${DATE_FORMAT})`).option("--rename <newName>", "Rename version").description("Update a version").action((name, options) => {
   const opts = getOutputOptions(versionCommand);
   const projectRoot = findProjectRoot();
   if (!projectRoot) {
@@ -6293,7 +7279,10 @@ versionCommand.command("update").argument("<name>", "Version name").option("-d,
     error(`Project "${config.project.key}" not found.`, opts);
     process.exit(1);
   }
-  const version = queryOne("SELECT id FROM versions WHERE project_id = ? AND name = ?", [project.id, name]);
+  const version = queryOne(
+    "SELECT id, start_date, release_date FROM versions WHERE project_id = ? AND name = ?",
+    [project.id, name]
+  );
   if (!version) {
     error(`Version "${name}" not found.`, opts);
     process.exit(1);
@@ -6306,15 +7295,30 @@ versionCommand.command("update").argument("<name>", "Version name").option("-d,
     params.push(options.description);
     changes.description = options.description;
   }
-  if (options.start !== void 0) {
-    updates.push("start_date = ?");
-    params.push(options.start);
-    changes.start_date = options.start;
+  let startDate = null;
+  let releaseDate = null;
+  try {
+    if (options.start !== void 0) {
+      startDate = validateAndStandardizeDate(options.start, "start date");
+      updates.push("start_date = ?");
+      params.push(startDate);
+      changes.start_date = startDate;
+    }
+    if (options.release !== void 0) {
+      releaseDate = validateAndStandardizeDate(options.release, "release date");
+      updates.push("release_date = ?");
+      params.push(releaseDate);
+      changes.release_date = releaseDate;
+    }
+  } catch (err) {
+    error(err instanceof Error ? err.message : String(err), opts);
+    process.exit(1);
   }
-  if (options.release !== void 0) {
-    updates.push("release_date = ?");
-    params.push(options.release);
-    changes.release_date = options.release;
+  const effectiveStart = startDate ?? version.start_date;
+  const effectiveRelease = releaseDate ?? version.release_date;
+  if (effectiveStart && effectiveRelease && !isEndDateValid(effectiveStart, effectiveRelease)) {
+    error(`Release date (${effectiveRelease}) must be after start date (${effectiveStart}).`, opts);
+    process.exit(1);
   }
   if (options.rename) {
     const existing = queryOne("SELECT id FROM versions WHERE project_id = ? AND name = ?", [project.id, options.rename]);
@@ -6874,7 +7878,7 @@ uxJourneyCommand.command("delete").alias("rm").argument("<key>", "Journey key").
 init_connection();
 import { Command as Command19 } from "commander";
 import { readFileSync as readFileSync7, writeFileSync as writeFileSync5 } from "fs";
-import { join as join7 } from "path";
+import { join as join8 } from "path";
 init_config();
 var docCommand = new Command19("doc").description("Document management and frontmatter operations");
 function getProjectId(opts) {
@@ -6954,7 +7958,7 @@ docCommand.command("show <path>").description("Show document details including f
     error(`Document not found: ${filePath}`, opts);
     process.exit(1);
   }
-  const fullPath = join7(ctx.projectRoot, filePath);
+  const fullPath = join8(ctx.projectRoot, filePath);
   const parsed = parseFrontmatterFromFile(fullPath);
   if (opts.json) {
     console.log(JSON.stringify({
@@ -7016,7 +8020,7 @@ docCommand.command("update <path>").option("--status <status>", "Set metadata st
   if (!ctx) {
     process.exit(1);
   }
-  const fullPath = join7(ctx.projectRoot, filePath);
+  const fullPath = join8(ctx.projectRoot, filePath);
   let content;
   try {
     content = readFileSync7(fullPath, "utf-8");
@@ -7089,7 +8093,7 @@ docCommand.command("init-frontmatter <path>").option("--status <status>", "Initi
   if (!ctx) {
     process.exit(1);
   }
-  const fullPath = join7(ctx.projectRoot, filePath);
+  const fullPath = join8(ctx.projectRoot, filePath);
   let content;
   try {
     content = readFileSync7(fullPath, "utf-8");
@@ -7163,38 +8167,46 @@ docCommand.command("stats").description("Show frontmatter statistics for the pro
 // src/commands/daemon.ts
 init_connection();
 import { Command as Command20 } from "commander";
-import { existsSync as existsSync7, writeFileSync as writeFileSync6, unlinkSync, readFileSync as readFileSync9, mkdirSync as mkdirSync5 } from "fs";
-import { join as join9, dirname as dirname4 } from "path";
+import { existsSync as existsSync9, writeFileSync as writeFileSync6, unlinkSync, readFileSync as readFileSync9, mkdirSync as mkdirSync5, statSync as statSync3, renameSync, readdirSync as readdirSync2 } from "fs";
+import { join as join11, dirname as dirname3 } from "path";
 import { homedir as homedir2, platform } from "os";
 import { spawn, execSync as execSync2 } from "child_process";
 init_config();
 
+// src/services/daemon-manager.ts
+import { existsSync as existsSync8 } from "fs";
+import { join as join10 } from "path";
+import { EventEmitter as EventEmitter2 } from "events";
+
 // src/services/file-watcher.ts
 init_connection();
 import { watch } from "chokidar";
-import { join as join8, relative as relative3, extname as extname2 } from "path";
-import { existsSync as existsSync6, readFileSync as readFileSync8, statSync as statSync2 } from "fs";
+import { relative as relative3, extname as extname2, basename as basename4 } from "path";
+import { readFileSync as readFileSync8, statSync as statSync2 } from "fs";
 import { EventEmitter } from "events";
-var DEFAULT_PATTERNS2 = ["**/*.md", "**/*.feature", "**/*.yaml", "**/*.yml"];
-var DEFAULT_IGNORE2 = [
-  "**/node_modules/**",
-  "**/.git/**",
-  "**/dist/**",
-  "**/coverage/**",
-  "**/.aigile/**"
-];
+init_monitoring_patterns();
+init_config();
+import picomatch2 from "picomatch";
 var FileWatcher = class extends EventEmitter {
   watcher = null;
   config;
   stats;
   debounceTimers = /* @__PURE__ */ new Map();
+  // Tri-state pattern matchers
+  allowMatcher = null;
+  denyMatcher = null;
+  hardIgnoreMatcher = null;
   constructor(config) {
     super();
+    const projectAllowPatterns = config.patterns ?? loadAllowPatterns(config.projectPath);
+    const projectDenyPatterns = config.ignore ?? loadIgnorePatterns(config.projectPath);
     this.config = {
-      patterns: DEFAULT_PATTERNS2,
-      ignore: DEFAULT_IGNORE2,
-      useGitignore: true,
+      patterns: projectAllowPatterns.length > 0 ? projectAllowPatterns : getDefaultAllowPatterns(),
+      ignore: projectDenyPatterns.length > 0 ? projectDenyPatterns : getDefaultDenyPatterns(),
+      useGitignore: false,
+      // Changed: don't use gitignore by default
       debounceMs: 300,
+      trackUnknown: true,
       ...config
     };
     this.stats = {
@@ -7202,8 +8214,37 @@ var FileWatcher = class extends EventEmitter {
       startedAt: null,
       filesWatched: 0,
       eventsProcessed: 0,
-      lastEvent: null
+      lastEvent: null,
+      categoryCounts: {
+        allow: 0,
+        deny: 0,
+        unknown: 0
+      }
     };
+    this.initializeMatchers();
+  }
+  /**
+   * Initialize picomatch matchers for tri-state classification
+   */
+  initializeMatchers() {
+    this.hardIgnoreMatcher = picomatch2(getHardIgnorePatterns());
+    this.allowMatcher = picomatch2(this.config.patterns);
+    this.denyMatcher = picomatch2(this.config.ignore);
+  }
+  /**
+   * Classify a file into allow/deny/unknown category
+   */
+  classifyFile(relativePath) {
+    if (this.hardIgnoreMatcher && this.hardIgnoreMatcher(relativePath)) {
+      return "deny";
+    }
+    if (this.allowMatcher && this.allowMatcher(relativePath)) {
+      return "allow";
+    }
+    if (this.denyMatcher && this.denyMatcher(relativePath)) {
+      return "deny";
+    }
+    return "unknown";
   }
   /**
    * Start watching for file changes
@@ -7212,16 +8253,16 @@ var FileWatcher = class extends EventEmitter {
     if (this.watcher) {
       return;
     }
-    const watchPaths = this.config.patterns.map((p) => join8(this.config.projectPath, p));
-    const ignorePatterns = this.buildIgnorePatterns();
-    this.watcher = watch(watchPaths, {
-      ignored: ignorePatterns,
+    this.watcher = watch(this.config.projectPath, {
+      ignored: getHardIgnorePatterns(),
       persistent: true,
       ignoreInitial: true,
       awaitWriteFinish: {
         stabilityThreshold: 200,
         pollInterval: 100
-      }
+      },
+      // Watch all directories but we'll filter files during processing
+      depth: Infinity
     });
     this.watcher.on("add", (path) => this.handleFileEvent("add", path));
     this.watcher.on("change", (path) => this.handleFileEvent("change", path));
@@ -7231,9 +8272,32 @@ var FileWatcher = class extends EventEmitter {
       this.stats.isRunning = true;
       this.stats.startedAt = /* @__PURE__ */ new Date();
       this.stats.filesWatched = this.getWatchedFilesCount();
+      this.updateCategoryCounts();
       this.emit("ready", this.stats);
     });
   }
+  /**
+   * Update category counts from database
+   * This is best-effort - if DB isn't ready, we'll get counts later
+   */
+  updateCategoryCounts() {
+    try {
+      const counts = queryAll(`
+        SELECT monitoring_category, COUNT(*) as count
+        FROM documents
+        WHERE project_id = ? AND status != 'deleted'
+        GROUP BY monitoring_category
+      `, [this.config.projectId]);
+      this.stats.categoryCounts = { allow: 0, deny: 0, unknown: 0 };
+      for (const row of counts) {
+        const cat = row.monitoring_category;
+        if (cat in this.stats.categoryCounts) {
+          this.stats.categoryCounts[cat] = row.count;
+        }
+      }
+    } catch {
+    }
+  }
   /**
    * Stop watching for file changes
    */
@@ -7257,18 +8321,16 @@ var FileWatcher = class extends EventEmitter {
     return { ...this.stats };
   }
   /**
-   * Build ignore patterns including gitignore if enabled
+   * Get the project path being watched
    */
-  buildIgnorePatterns() {
-    const patterns = [...this.config.ignore || []];
-    if (this.config.useGitignore) {
-      const gitignorePath = join8(this.config.projectPath, ".gitignore");
-      if (existsSync6(gitignorePath)) {
-        const gitignorePatterns = parseGitignore(gitignorePath);
-        patterns.push(...gitignorePatterns);
-      }
-    }
-    return patterns;
+  getProjectPath() {
+    return this.config.projectPath;
+  }
+  /**
+   * Get the project ID
+   */
+  getProjectId() {
+    return this.config.projectId;
   }
   /**
    * Handle a file event with debouncing
@@ -7289,20 +8351,28 @@ var FileWatcher = class extends EventEmitter {
    */
   processFileEvent(type, absolutePath) {
     const relativePath = relative3(this.config.projectPath, absolutePath);
+    const category = this.classifyFile(relativePath);
+    if (category === "deny" && type !== "unlink") {
+      return;
+    }
+    if (category === "unknown" && !this.config.trackUnknown && type !== "unlink") {
+      return;
+    }
     const event = {
       type,
       path: relativePath,
-      timestamp: /* @__PURE__ */ new Date()
+      timestamp: /* @__PURE__ */ new Date(),
+      category
     };
     this.stats.lastEvent = event;
     this.stats.eventsProcessed++;
     try {
       switch (type) {
         case "add":
-          this.syncFileAdd(absolutePath, relativePath);
+          this.syncFileAdd(absolutePath, relativePath, category);
           break;
         case "change":
-          this.syncFileChange(absolutePath, relativePath);
+          this.syncFileChange(absolutePath, relativePath, category);
           break;
         case "unlink":
           this.syncFileDelete(relativePath);
@@ -7316,16 +8386,18 @@ var FileWatcher = class extends EventEmitter {
   /**
    * Sync a new file to the database
    */
-  syncFileAdd(absolutePath, relativePath) {
+  syncFileAdd(absolutePath, relativePath, category) {
     const ext = extname2(relativePath).slice(1);
-    const filename = relativePath.split("/").pop() || relativePath;
+    const filename = basename4(relativePath);
+    const isBinary = isBinaryExtension(ext);
     try {
       const stats = statSync2(absolutePath);
-      const hash = computeFileHash(absolutePath);
+      const shouldComputeHash = category === "allow" || !isBinary && stats.size < 10 * 1024 * 1024;
+      const hash = shouldComputeHash ? computeFileHash(absolutePath) : null;
       let hasFrontmatter = false;
       let frontmatterRaw = null;
       let metadata = null;
-      if (ext === "md" || ext === "markdown") {
+      if (category === "allow" && (ext === "md" || ext === "markdown") && !isBinary) {
         const parsed = parseFrontmatterFromFile(absolutePath);
         if (parsed) {
           hasFrontmatter = true;
@@ -7338,18 +8410,23 @@ var FileWatcher = class extends EventEmitter {
         [this.config.projectId, relativePath]
       );
       if (existing) {
-        this.updateDocument(existing.id, hash, stats.size, hasFrontmatter, frontmatterRaw, metadata);
+        this.updateDocument(existing.id, hash, stats.size, hasFrontmatter, frontmatterRaw, metadata, category);
       } else {
-        this.insertDocument(relativePath, filename, ext, hash, stats.size, hasFrontmatter, frontmatterRaw, metadata);
+        this.insertDocument(relativePath, filename, ext, hash, stats.size, hasFrontmatter, frontmatterRaw, metadata, category);
       }
-    } catch {
+    } catch (err) {
+      const errMsg = err instanceof Error ? err.message : String(err);
+      if (errMsg.includes("Database") || errMsg.includes("database")) {
+        throw err;
+      }
+      console.error(`[${(/* @__PURE__ */ new Date()).toISOString()}] syncFileAdd error for ${relativePath}: ${errMsg}`);
     }
   }
   /**
    * Sync a changed file to the database
    */
-  syncFileChange(absolutePath, relativePath) {
-    this.syncFileAdd(absolutePath, relativePath);
+  syncFileChange(absolutePath, relativePath, category) {
+    this.syncFileAdd(absolutePath, relativePath, category);
   }
   /**
    * Mark a file as deleted in the database
@@ -7369,14 +8446,16 @@ var FileWatcher = class extends EventEmitter {
   /**
    * Insert a new document into the database
    */
-  insertDocument(path, filename, extension, hash, size, hasFrontmatter, frontmatterRaw, metadata) {
+  insertDocument(path, filename, extension, hash, size, hasFrontmatter, frontmatterRaw, metadata, category) {
     const now = (/* @__PURE__ */ new Date()).toISOString();
+    const needsReview = category === "unknown" ? 1 : 0;
     run(
       `INSERT INTO documents (
         id, project_id, path, filename, extension, content_hash, size_bytes, status, last_scanned_at,
         has_frontmatter, frontmatter_raw, meta_status, meta_version, meta_tldr, meta_title,
-        meta_modules, meta_dependencies, meta_code_refs, meta_authors
-      ) VALUES (?, ?, ?, ?, ?, ?, ?, 'tracked', ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+        meta_modules, meta_dependencies, meta_code_refs, meta_authors,
+        monitoring_category, needs_review
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, 'tracked', ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
       [
         generateId(),
         this.config.projectId,
@@ -7395,20 +8474,23 @@ var FileWatcher = class extends EventEmitter {
         metadata?.modules ? JSON.stringify(metadata.modules) : null,
         metadata?.dependencies ? JSON.stringify(metadata.dependencies) : null,
         metadata?.code_refs ? JSON.stringify(metadata.code_refs) : null,
-        metadata?.authors ? JSON.stringify(metadata.authors) : null
+        metadata?.authors ? JSON.stringify(metadata.authors) : null,
+        category,
+        needsReview
       ]
     );
   }
   /**
    * Update an existing document in the database
    */
-  updateDocument(id, hash, size, hasFrontmatter, frontmatterRaw, metadata) {
+  updateDocument(id, hash, size, hasFrontmatter, frontmatterRaw, metadata, category) {
     const now = (/* @__PURE__ */ new Date()).toISOString();
     run(
       `UPDATE documents SET
-        content_hash = ?, size_bytes = ?, status = 'tracked', last_scanned_at = ?, updated_at = datetime('now'),
+        content_hash = COALESCE(?, content_hash), size_bytes = ?, status = 'tracked', last_scanned_at = ?, updated_at = datetime('now'),
         has_frontmatter = ?, frontmatter_raw = ?, meta_status = ?, meta_version = ?, meta_tldr = ?, meta_title = ?,
-        meta_modules = ?, meta_dependencies = ?, meta_code_refs = ?, meta_authors = ?
+        meta_modules = ?, meta_dependencies = ?, meta_code_refs = ?, meta_authors = ?,
+        monitoring_category = ?
        WHERE id = ?`,
       [
         hash,
@@ -7424,6 +8506,7 @@ var FileWatcher = class extends EventEmitter {
         metadata?.dependencies ? JSON.stringify(metadata.dependencies) : null,
         metadata?.code_refs ? JSON.stringify(metadata.code_refs) : null,
         metadata?.authors ? JSON.stringify(metadata.authors) : null,
+        category,
         id
       ]
     );
@@ -7443,65 +8526,275 @@ var FileWatcher = class extends EventEmitter {
     return count;
   }
 };
-function parseGitignore(gitignorePath) {
-  try {
-    const content = readFileSync8(gitignorePath, "utf-8");
-    const patterns = [];
-    for (let line of content.split("\n")) {
-      line = line.trim();
-      if (!line || line.startsWith("#")) {
-        continue;
-      }
-      if (line.startsWith("!")) {
-        continue;
-      }
-      let pattern = line;
-      if (pattern.startsWith("/")) {
-        pattern = pattern.slice(1);
+
+// src/services/daemon-manager.ts
+init_connection();
+var MAX_WATCHER_RETRIES = 3;
+var INITIAL_RETRY_DELAY_MS = 5e3;
+var DaemonManager = class extends EventEmitter2 {
+  watchers = /* @__PURE__ */ new Map();
+  watcherRetries = /* @__PURE__ */ new Map();
+  running = false;
+  startedAt = null;
+  /**
+   * Start watching all registered projects
+   */
+  async start() {
+    if (this.running) {
+      throw new Error("Daemon is already running");
+    }
+    const projects = await this.getActiveProjects();
+    if (projects.length === 0) {
+      console.log('No valid projects to watch. Register projects with "aigile init".');
+      this.running = true;
+      this.startedAt = /* @__PURE__ */ new Date();
+      return this.getStatus();
+    }
+    console.log(`Starting watchers for ${projects.length} project(s)...`);
+    for (const project of projects) {
+      await this.startWatcherWithRetry(project);
+    }
+    this.running = true;
+    this.startedAt = /* @__PURE__ */ new Date();
+    this.emit("started", { projectCount: this.watchers.size });
+    return this.getStatus();
+  }
+  /**
+   * Start a watcher for a project with automatic retry on failure
+   */
+  async startWatcherWithRetry(project) {
+    const retryCount = this.watcherRetries.get(project.key) ?? 0;
+    try {
+      const config = {
+        projectId: project.id,
+        projectPath: project.path,
+        trackUnknown: true
+      };
+      const watcher = new FileWatcher(config);
+      watcher.on("sync", (event) => {
+        this.emit("sync", { project: project.key, ...event });
+      });
+      watcher.on("syncError", (data2) => {
+        this.emit("syncError", { project: project.key, ...data2 });
+      });
+      watcher.on("error", async (err) => {
+        console.error(`[${(/* @__PURE__ */ new Date()).toISOString()}] [${project.key}] Watcher error: ${err}`);
+        this.emit("watcherError", { project: project.key, error: err });
+        try {
+          await watcher.stop();
+        } catch {
+        }
+        this.watchers.delete(project.key);
+        const currentRetries = this.watcherRetries.get(project.key) ?? 0;
+        if (currentRetries < MAX_WATCHER_RETRIES) {
+          this.watcherRetries.set(project.key, currentRetries + 1);
+          const delay = INITIAL_RETRY_DELAY_MS * Math.pow(2, currentRetries);
+          console.log(`[${(/* @__PURE__ */ new Date()).toISOString()}] [${project.key}] Will retry in ${delay}ms (attempt ${currentRetries + 1}/${MAX_WATCHER_RETRIES})`);
+          setTimeout(async () => {
+            if (this.running) {
+              console.log(`[${(/* @__PURE__ */ new Date()).toISOString()}] [${project.key}] Attempting restart...`);
+              await this.startWatcherWithRetry(project);
+            }
+          }, delay);
+        } else {
+          console.error(`[${(/* @__PURE__ */ new Date()).toISOString()}] [${project.key}] Max retries (${MAX_WATCHER_RETRIES}) exceeded - watcher disabled`);
+          this.emit("watcherDisabled", { project: project.key });
+        }
+      });
+      watcher.start();
+      this.watchers.set(project.key, watcher);
+      this.watcherRetries.set(project.key, 0);
+      console.log(`  \u2713 ${project.key}: ${project.path}`);
+    } catch (error2) {
+      console.error(`  \u2717 ${project.key}: Failed to start watcher - ${error2}`);
+      this.emit("watcherError", { project: project.key, error: error2 });
+      if (retryCount < MAX_WATCHER_RETRIES) {
+        this.watcherRetries.set(project.key, retryCount + 1);
+        const delay = INITIAL_RETRY_DELAY_MS * Math.pow(2, retryCount);
+        console.log(`[${(/* @__PURE__ */ new Date()).toISOString()}] [${project.key}] Will retry in ${delay}ms (attempt ${retryCount + 1}/${MAX_WATCHER_RETRIES})`);
+        setTimeout(async () => {
+          if (this.running) {
+            await this.startWatcherWithRetry(project);
+          }
+        }, delay);
       }
-      if (!pattern.startsWith("**/") && !pattern.includes("/")) {
-        pattern = `**/${pattern}`;
+    }
+  }
+  /**
+   * Stop all watchers
+   */
+  async stop() {
+    if (!this.running) {
+      return;
+    }
+    console.log("Stopping all watchers...");
+    for (const [key, watcher] of this.watchers) {
+      try {
+        await watcher.stop();
+        console.log(`  \u2713 Stopped: ${key}`);
+      } catch (error2) {
+        console.error(`  \u2717 Error stopping ${key}: ${error2}`);
       }
-      if (pattern.endsWith("/")) {
-        pattern = pattern.slice(0, -1) + "/**";
+    }
+    this.watchers.clear();
+    this.running = false;
+    this.startedAt = null;
+    this.emit("stopped");
+  }
+  /**
+   * Resync all projects
+   */
+  async resyncAll() {
+    const results = {};
+    const projects = await this.getActiveProjects();
+    console.log(`Resyncing ${projects.length} project(s)...`);
+    for (const project of projects) {
+      try {
+        const files = scanDirectory(project.path);
+        const syncResult = syncFilesToDatabase(project.id, project.path, files);
+        const status = getSyncStatus(project.id);
+        const result = {
+          total: syncResult.total,
+          new: syncResult.new,
+          modified: syncResult.modified,
+          deleted: syncResult.deleted,
+          unchanged: syncResult.unchanged,
+          allow: status.byCategory.allow,
+          deny: status.byCategory.deny,
+          unknown: status.byCategory.unknown
+        };
+        results[project.key] = result;
+        console.log(`  \u2713 ${project.key}: ${result.allow} allow, ${result.unknown} unknown`);
+      } catch (error2) {
+        console.error(`  \u2717 ${project.key}: Resync failed - ${error2}`);
       }
-      patterns.push(pattern);
     }
-    return patterns;
-  } catch {
-    return [];
+    return results;
   }
-}
-function createFileWatcher(config) {
-  return new FileWatcher(config);
-}
-
+  /**
+   * Resync a specific project
+   */
+  async resyncProject(key) {
+    const projects = await this.getActiveProjects();
+    const project = projects.find((p) => p.key === key);
+    if (!project) {
+      throw new Error(`Project "${key}" not found or invalid`);
+    }
+    const files = scanDirectory(project.path);
+    const syncResult = syncFilesToDatabase(project.id, project.path, files);
+    const status = getSyncStatus(project.id);
+    return {
+      total: syncResult.total,
+      new: syncResult.new,
+      modified: syncResult.modified,
+      deleted: syncResult.deleted,
+      unchanged: syncResult.unchanged,
+      allow: status.byCategory.allow,
+      deny: status.byCategory.deny,
+      unknown: status.byCategory.unknown
+    };
+  }
+  /**
+   * Get daemon status
+   */
+  getStatus() {
+    const projectStatuses = [];
+    const totalFiles = { allow: 0, deny: 0, unknown: 0 };
+    const allProjects = queryAll("SELECT * FROM projects ORDER BY key");
+    for (const project of allProjects) {
+      const valid = this.isValidProject(project.path);
+      const watcher = this.watchers.get(project.key);
+      const stats = watcher?.getStats() ?? null;
+      if (stats) {
+        totalFiles.allow += stats.categoryCounts.allow;
+        totalFiles.deny += stats.categoryCounts.deny;
+        totalFiles.unknown += stats.categoryCounts.unknown;
+      }
+      projectStatuses.push({
+        key: project.key,
+        name: project.name,
+        path: project.path,
+        valid,
+        watching: watcher !== void 0,
+        stats
+      });
+    }
+    return {
+      running: this.running,
+      projectCount: allProjects.length,
+      watchingCount: this.watchers.size,
+      projects: projectStatuses,
+      totalFiles
+    };
+  }
+  /**
+   * Check if daemon is running
+   */
+  isRunning() {
+    return this.running;
+  }
+  /**
+   * Get uptime in milliseconds
+   */
+  getUptime() {
+    if (!this.startedAt) {
+      return 0;
+    }
+    return Date.now() - this.startedAt.getTime();
+  }
+  /**
+   * Get all valid registered projects
+   */
+  async getActiveProjects() {
+    const projects = queryAll("SELECT * FROM projects ORDER BY key");
+    return projects.filter((p) => this.isValidProject(p.path));
+  }
+  /**
+   * Check if a project path is valid
+   */
+  isValidProject(path) {
+    return existsSync8(path) && existsSync8(join10(path, ".aigile"));
+  }
+};
+var daemonManagerInstance = null;
+function getDaemonManager() {
+  if (!daemonManagerInstance) {
+    daemonManagerInstance = new DaemonManager();
+  }
+  return daemonManagerInstance;
+}
+
 // src/commands/daemon.ts
+var CRASH_DIR_NAME = "crashes";
+var MAX_CRASH_REPORTS = 10;
+var MAX_LOG_SIZE = 10 * 1024 * 1024;
+var MAX_LOG_FILES = 5;
+var SHUTDOWN_TIMEOUT_MS = 1e4;
 var daemonCommand = new Command20("daemon").description("Manage the file watcher daemon");
 var PLATFORM = platform();
 var DAEMON_NAME = "com.aigile.watcher";
 function getDaemonPaths() {
   const aigileHome = getAigileHome();
   const basePaths = {
-    pidFile: join9(aigileHome, "daemon.pid"),
-    logFile: join9(aigileHome, "daemon.log")
+    pidFile: join11(aigileHome, "daemon.pid"),
+    logFile: join11(aigileHome, "daemon.log")
   };
   if (PLATFORM === "darwin") {
     return {
       ...basePaths,
-      plist: join9(homedir2(), "Library", "LaunchAgents", `${DAEMON_NAME}.plist`)
+      plist: join11(homedir2(), "Library", "LaunchAgents", `${DAEMON_NAME}.plist`)
     };
   } else if (PLATFORM === "linux") {
     return {
       ...basePaths,
-      service: join9(homedir2(), ".config", "systemd", "user", `${DAEMON_NAME}.service`)
+      service: join11(homedir2(), ".config", "systemd", "user", `${DAEMON_NAME}.service`)
     };
   }
   return basePaths;
 }
 function isDaemonRunning() {
   const paths = getDaemonPaths();
-  if (!existsSync7(paths.pidFile)) {
+  if (!existsSync9(paths.pidFile)) {
     return { running: false };
   }
   try {
@@ -7517,10 +8810,78 @@ function isDaemonRunning() {
     return { running: false };
   }
 }
-function generateLaunchAgentPlist(projectPath) {
+function writeCrashReport(error2) {
+  try {
+    const crashDir = join11(getAigileHome(), CRASH_DIR_NAME);
+    if (!existsSync9(crashDir)) {
+      mkdirSync5(crashDir, { recursive: true });
+    }
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+    const crashFile = join11(crashDir, `crash-${timestamp}.log`);
+    const report = [
+      `AIGILE Daemon Crash Report`,
+      `==========================`,
+      ``,
+      `Time: ${(/* @__PURE__ */ new Date()).toISOString()}`,
+      `Node: ${process.version}`,
+      `Platform: ${platform()}`,
+      `PID: ${process.pid}`,
+      ``,
+      `Error:`,
+      error2 instanceof Error ? error2.stack || error2.message : String(error2)
+    ].join("\n");
+    writeFileSync6(crashFile, report);
+    console.error(`[${(/* @__PURE__ */ new Date()).toISOString()}] Crash report saved: ${crashFile}`);
+    cleanupOldCrashReports(crashDir);
+  } catch (writeErr) {
+    console.error(`[${(/* @__PURE__ */ new Date()).toISOString()}] Failed to write crash report: ${writeErr}`);
+  }
+}
+function cleanupOldCrashReports(crashDir) {
+  try {
+    const files = readdirSync2(crashDir).filter((f) => f.startsWith("crash-") && f.endsWith(".log")).map((f) => ({ name: f, path: join11(crashDir, f) })).sort((a, b) => b.name.localeCompare(a.name));
+    for (let i = MAX_CRASH_REPORTS; i < files.length; i++) {
+      try {
+        unlinkSync(files[i].path);
+      } catch {
+      }
+    }
+  } catch {
+  }
+}
+function rotateLogIfNeeded() {
+  const paths = getDaemonPaths();
+  const logPath = paths.logFile;
+  try {
+    if (!existsSync9(logPath)) return;
+    const stats = statSync3(logPath);
+    if (stats.size < MAX_LOG_SIZE) return;
+    const timestamp = Date.now();
+    const rotatedPath = `${logPath}.${timestamp}`;
+    renameSync(logPath, rotatedPath);
+    console.log(`[${(/* @__PURE__ */ new Date()).toISOString()}] Log rotated: ${rotatedPath}`);
+    cleanupOldLogs(dirname3(logPath));
+  } catch (err) {
+    console.error(`[${(/* @__PURE__ */ new Date()).toISOString()}] Log rotation error: ${err}`);
+  }
+}
+function cleanupOldLogs(logDir) {
+  try {
+    const files = readdirSync2(logDir).filter((f) => f.startsWith("daemon.log.")).map((f) => ({ name: f, path: join11(logDir, f) })).sort((a, b) => b.name.localeCompare(a.name));
+    for (let i = MAX_LOG_FILES; i < files.length; i++) {
+      try {
+        unlinkSync(files[i].path);
+        console.log(`[${(/* @__PURE__ */ new Date()).toISOString()}] Removed old log: ${files[i].name}`);
+      } catch {
+      }
+    }
+  } catch {
+  }
+}
+function generateLaunchAgentPlist() {
   const paths = getDaemonPaths();
   const nodePath = process.execPath;
-  const aigilePath = join9(dirname4(dirname4(import.meta.url.replace("file://", ""))), "bin", "aigile.js");
+  const aigilePath = join11(dirname3(dirname3(import.meta.url.replace("file://", ""))), "bin", "aigile.js");
   return `<?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
 <plist version="1.0">
@@ -7533,15 +8894,18 @@ function generateLaunchAgentPlist(projectPath) {
         <string>${aigilePath}</string>
         <string>daemon</string>
         <string>run</string>
-        <string>--project</string>
-        <string>${projectPath}</string>
     </array>
     <key>WorkingDirectory</key>
-    <string>${projectPath}</string>
+    <string>${homedir2()}</string>
     <key>RunAtLoad</key>
     <true/>
     <key>KeepAlive</key>
-    <true/>
+    <dict>
+        <key>SuccessfulExit</key>
+        <false/>
+    </dict>
+    <key>ThrottleInterval</key>
+    <integer>10</integer>
     <key>StandardOutPath</key>
     <string>${paths.logFile}</string>
     <key>StandardErrorPath</key>
@@ -7549,56 +8913,55 @@ function generateLaunchAgentPlist(projectPath) {
 </dict>
 </plist>`;
 }
-function generateSystemdService(projectPath) {
+function generateSystemdService() {
   const paths = getDaemonPaths();
   const nodePath = process.execPath;
-  const aigilePath = join9(dirname4(dirname4(import.meta.url.replace("file://", ""))), "bin", "aigile.js");
+  const aigilePath = join11(dirname3(dirname3(import.meta.url.replace("file://", ""))), "bin", "aigile.js");
   return `[Unit]
 Description=AIGILE File Watcher Daemon
 After=network.target
 
 [Service]
 Type=simple
-ExecStart=${nodePath} ${aigilePath} daemon run --project ${projectPath}
-WorkingDirectory=${projectPath}
-Restart=always
-RestartSec=5
+ExecStart=${nodePath} ${aigilePath} daemon run
+WorkingDirectory=${homedir2()}
+Restart=on-failure
+RestartSec=10
+StartLimitIntervalSec=300
+StartLimitBurst=5
 StandardOutput=append:${paths.logFile}
 StandardError=append:${paths.logFile}
 
 [Install]
 WantedBy=default.target`;
 }
-daemonCommand.command("install").description("Install daemon to start automatically on system boot").action(() => {
+daemonCommand.command("install").description("Install daemon to start automatically on system boot (watches ALL registered projects)").action(() => {
   const opts = getOutputOptions(daemonCommand);
-  const projectRoot = findProjectRoot();
-  if (!projectRoot) {
-    error('Not in an AIGILE project. Run "aigile init" first.', opts);
-    process.exit(1);
-  }
   const paths = getDaemonPaths();
   if (PLATFORM === "darwin") {
-    const plistDir = dirname4(paths.plist);
-    if (!existsSync7(plistDir)) {
+    const plistDir = dirname3(paths.plist);
+    if (!existsSync9(plistDir)) {
       mkdirSync5(plistDir, { recursive: true });
     }
-    const plistContent = generateLaunchAgentPlist(projectRoot);
+    const plistContent = generateLaunchAgentPlist();
     writeFileSync6(paths.plist, plistContent);
     success("Installed macOS LaunchAgent", opts);
     info(`Plist location: ${paths.plist}`, opts);
+    info("Daemon will watch ALL registered projects", opts);
     info('Run "aigile daemon start" to start the watcher', opts);
   } else if (PLATFORM === "linux") {
-    const serviceDir = dirname4(paths.service);
-    if (!existsSync7(serviceDir)) {
+    const serviceDir = dirname3(paths.service);
+    if (!existsSync9(serviceDir)) {
       mkdirSync5(serviceDir, { recursive: true });
     }
-    const serviceContent = generateSystemdService(projectRoot);
+    const serviceContent = generateSystemdService();
     writeFileSync6(paths.service, serviceContent);
     try {
       execSync2("systemctl --user daemon-reload");
       execSync2(`systemctl --user enable ${DAEMON_NAME}`);
       success("Installed and enabled systemd user service", opts);
       info(`Service location: ${paths.service}`, opts);
+      info("Daemon will watch ALL registered projects", opts);
       info('Run "aigile daemon start" to start the watcher', opts);
     } catch (err) {
       warning("Service file created but could not enable. You may need to run:", opts);
@@ -7622,14 +8985,14 @@ daemonCommand.command("uninstall").description("Remove daemon from auto-start").
     } catch {
     }
   }
-  if (PLATFORM === "darwin" && paths.plist && existsSync7(paths.plist)) {
+  if (PLATFORM === "darwin" && paths.plist && existsSync9(paths.plist)) {
     try {
       execSync2(`launchctl unload ${paths.plist}`);
     } catch {
     }
     unlinkSync(paths.plist);
     success("Removed macOS LaunchAgent", opts);
-  } else if (PLATFORM === "linux" && paths.service && existsSync7(paths.service)) {
+  } else if (PLATFORM === "linux" && paths.service && existsSync9(paths.service)) {
     try {
       execSync2(`systemctl --user stop ${DAEMON_NAME}`);
       execSync2(`systemctl --user disable ${DAEMON_NAME}`);
@@ -7644,11 +9007,11 @@ daemonCommand.command("uninstall").description("Remove daemon from auto-start").
   } else {
     info("No daemon installation found", opts);
   }
-  if (existsSync7(paths.pidFile)) {
+  if (existsSync9(paths.pidFile)) {
     unlinkSync(paths.pidFile);
   }
 });
-daemonCommand.command("start").description("Start the file watcher daemon").action(() => {
+daemonCommand.command("start").description("Start the file watcher daemon (watches ALL registered projects)").action(() => {
   const opts = getOutputOptions(daemonCommand);
   const paths = getDaemonPaths();
   const status = isDaemonRunning();
@@ -7656,36 +9019,37 @@ daemonCommand.command("start").description("Start the file watcher daemon").acti
     info(`Daemon already running (PID: ${status.pid})`, opts);
     return;
   }
-  if (PLATFORM === "darwin" && paths.plist && existsSync7(paths.plist)) {
+  if (PLATFORM === "darwin" && paths.plist && existsSync9(paths.plist)) {
     try {
       execSync2(`launchctl load ${paths.plist}`);
-      success("Started daemon via launchctl", opts);
+      success("Started daemon via launchctl (watching all projects)", opts);
     } catch (err) {
       error("Failed to start daemon via launchctl", opts);
       process.exit(1);
     }
-  } else if (PLATFORM === "linux" && paths.service && existsSync7(paths.service)) {
+  } else if (PLATFORM === "linux" && paths.service && existsSync9(paths.service)) {
     try {
       execSync2(`systemctl --user start ${DAEMON_NAME}`);
-      success("Started daemon via systemctl", opts);
+      success("Started daemon via systemctl (watching all projects)", opts);
     } catch (err) {
       error("Failed to start daemon via systemctl", opts);
       process.exit(1);
     }
   } else {
-    const projectRoot = findProjectRoot();
-    if (!projectRoot) {
-      error('Not in an AIGILE project. Run "aigile init" first.', opts);
-      process.exit(1);
-    }
-    const child = spawn(process.execPath, [process.argv[1], "daemon", "run", "--project", projectRoot], {
+    const child = spawn(process.execPath, [process.argv[1], "daemon", "run"], {
       detached: true,
       stdio: "ignore"
     });
     child.unref();
     if (child.pid) {
-      writeFileSync6(paths.pidFile, String(child.pid));
-      success(`Started daemon (PID: ${child.pid})`, opts);
+      try {
+        process.kill(child.pid, 0);
+        writeFileSync6(paths.pidFile, String(child.pid));
+        success(`Started daemon (PID: ${child.pid}) - watching all projects`, opts);
+      } catch {
+        error("Failed to start daemon - process died immediately", opts);
+        process.exit(1);
+      }
     } else {
       error("Failed to start daemon", opts);
       process.exit(1);
@@ -7695,14 +9059,14 @@ daemonCommand.command("start").description("Start the file watcher daemon").acti
 daemonCommand.command("stop").description("Stop the file watcher daemon").action(() => {
   const opts = getOutputOptions(daemonCommand);
   const paths = getDaemonPaths();
-  if (PLATFORM === "darwin" && paths.plist && existsSync7(paths.plist)) {
+  if (PLATFORM === "darwin" && paths.plist && existsSync9(paths.plist)) {
     try {
       execSync2(`launchctl unload ${paths.plist}`);
       success("Stopped daemon via launchctl", opts);
     } catch {
       info("Daemon was not running", opts);
     }
-  } else if (PLATFORM === "linux" && paths.service && existsSync7(paths.service)) {
+  } else if (PLATFORM === "linux" && paths.service && existsSync9(paths.service)) {
     try {
       execSync2(`systemctl --user stop ${DAEMON_NAME}`);
       success("Stopped daemon via systemctl", opts);
@@ -7714,7 +9078,7 @@ daemonCommand.command("stop").description("Stop the file watcher daemon").action
     if (status.running && status.pid) {
       try {
         process.kill(status.pid, "SIGTERM");
-        if (existsSync7(paths.pidFile)) {
+        if (existsSync9(paths.pidFile)) {
           unlinkSync(paths.pidFile);
         }
         success(`Stopped daemon (PID: ${status.pid})`, opts);
@@ -7727,97 +9091,215 @@ daemonCommand.command("stop").description("Stop the file watcher daemon").action
     }
   }
 });
-daemonCommand.command("status").description("Show daemon status").action(() => {
+daemonCommand.command("status").description("Show daemon status for ALL registered projects").action(() => {
   const opts = getOutputOptions(daemonCommand);
   const paths = getDaemonPaths();
   const status = isDaemonRunning();
-  const statusInfo = {
-    running: status.running ? "Yes" : "No",
-    pid: status.pid ?? "-",
-    platform: PLATFORM,
-    pid_file: paths.pidFile,
-    log_file: paths.logFile
-  };
-  if (PLATFORM === "darwin") {
-    statusInfo.plist = paths.plist ?? "-";
-    statusInfo.installed = paths.plist && existsSync7(paths.plist) ? "Yes" : "No";
-  } else if (PLATFORM === "linux") {
-    statusInfo.service = paths.service ?? "-";
-    statusInfo.installed = paths.service && existsSync7(paths.service) ? "Yes" : "No";
+  const projects = queryAll("SELECT id, key, name, path, is_default FROM projects ORDER BY is_default DESC, key");
+  const projectStats = [];
+  let totalFiles = { allow: 0, unknown: 0, total: 0 };
+  for (const project of projects) {
+    const valid = existsSync9(project.path) && existsSync9(join11(project.path, ".aigile"));
+    const counts = queryAll(`
+        SELECT COALESCE(monitoring_category, 'unknown') as monitoring_category, COUNT(*) as count
+        FROM documents
+        WHERE project_id = ? AND status != 'deleted'
+        GROUP BY monitoring_category
+      `, [project.id]);
+    let allow = 0;
+    let unknown = 0;
+    for (const row of counts) {
+      if (row.monitoring_category === "allow") allow = row.count;
+      else if (row.monitoring_category === "unknown") unknown = row.count;
+    }
+    projectStats.push({
+      key: project.key,
+      name: project.name,
+      path: project.path,
+      valid,
+      allow,
+      unknown,
+      total: allow + unknown
+    });
+    if (valid) {
+      totalFiles.allow += allow;
+      totalFiles.unknown += unknown;
+      totalFiles.total += allow + unknown;
+    }
   }
+  const validCount = projectStats.filter((p) => p.valid).length;
   if (opts.json) {
-    console.log(JSON.stringify({ success: true, data: statusInfo }));
-  } else {
-    details(
-      statusInfo,
-      [
-        { label: "Running", key: "running" },
-        { label: "PID", key: "pid" },
-        { label: "Platform", key: "platform" },
-        { label: "Installed", key: "installed" },
-        { label: "PID File", key: "pid_file" },
-        { label: "Log File", key: "log_file" }
-      ],
-      opts
-    );
+    console.log(JSON.stringify({
+      success: true,
+      data: {
+        running: status.running,
+        pid: status.pid ?? null,
+        platform: PLATFORM,
+        installed: PLATFORM === "darwin" ? paths.plist && existsSync9(paths.plist) : PLATFORM === "linux" ? paths.service && existsSync9(paths.service) : false,
+        projectCount: projects.length,
+        validProjectCount: validCount,
+        projects: projectStats,
+        totalFiles,
+        paths: {
+          database: getDbPath(),
+          pidFile: paths.pidFile,
+          logFile: paths.logFile
+        }
+      }
+    }));
+    return;
   }
-});
-daemonCommand.command("run").option("--project <path>", "Project path to watch").description("Run the file watcher in foreground (used by daemon)").action(async (options) => {
-  const opts = getOutputOptions(daemonCommand);
-  const paths = getDaemonPaths();
-  let projectRoot = options.project;
-  if (!projectRoot) {
-    projectRoot = findProjectRoot();
+  console.log("\n\u{1F4CA} Daemon Status\n");
+  console.log(`\u251C\u2500\u2500 Running: ${status.running ? "\u2705 Yes" : "\u274C No"}${status.pid ? ` (PID: ${status.pid})` : ""}`);
+  console.log(`\u251C\u2500\u2500 Platform: ${PLATFORM}`);
+  const installed = PLATFORM === "darwin" ? paths.plist && existsSync9(paths.plist) : PLATFORM === "linux" ? paths.service && existsSync9(paths.service) : false;
+  console.log(`\u251C\u2500\u2500 Installed: ${installed ? "\u2705 Yes" : "\u274C No"}`);
+  console.log(`\u251C\u2500\u2500 Projects: ${validCount}/${projects.length} valid`);
+  if (projectStats.length > 0) {
+    for (let i = 0; i < projectStats.length; i++) {
+      const p = projectStats[i];
+      const isLast = i === projectStats.length - 1;
+      const prefix = isLast ? "\u2502   \u2514\u2500\u2500" : "\u2502   \u251C\u2500\u2500";
+      const validStr = p.valid ? "\u2713" : "\u2717";
+      console.log(`${prefix} ${validStr} ${p.key}: ${p.allow} allow, ${p.unknown} unknown`);
+    }
   }
-  if (!projectRoot) {
-    error('Not in an AIGILE project. Run "aigile init" first.', opts);
-    process.exit(1);
+  console.log("\u251C\u2500\u2500 Total Files:");
+  console.log(`\u2502   \u251C\u2500\u2500 Allow (focus): ${totalFiles.allow}`);
+  console.log(`\u2502   \u2514\u2500\u2500 Unknown (review): ${totalFiles.unknown}`);
+  console.log("\u2514\u2500\u2500 System:");
+  console.log(`    \u251C\u2500\u2500 Database: ${getDbPath()}`);
+  console.log(`    \u251C\u2500\u2500 PID File: ${paths.pidFile}`);
+  console.log(`    \u2514\u2500\u2500 Log File: ${paths.logFile}`);
+  console.log("");
+  if (projectStats.some((p) => !p.valid)) {
+    console.log('\u26A0\uFE0F  Some projects have invalid paths. Run "aigile project cleanup" to remove them.\n');
   }
-  const config = loadProjectConfig(projectRoot);
-  if (!config) {
-    error("Could not load project config.", opts);
-    process.exit(1);
+});
+function getRelativeTime(isoDate) {
+  try {
+    const date = new Date(isoDate);
+    const now = /* @__PURE__ */ new Date();
+    const diffMs = now.getTime() - date.getTime();
+    const diffSec = Math.floor(diffMs / 1e3);
+    const diffMin = Math.floor(diffSec / 60);
+    const diffHour = Math.floor(diffMin / 60);
+    const diffDay = Math.floor(diffHour / 24);
+    if (diffSec < 60) return "just now";
+    if (diffMin < 60) return `${diffMin}m ago`;
+    if (diffHour < 24) return `${diffHour}h ago`;
+    return `${diffDay}d ago`;
+  } catch {
+    return isoDate;
   }
-  const project = queryOne("SELECT id FROM projects WHERE key = ?", [config.project.key]);
-  if (!project) {
-    error(`Project "${config.project.key}" not found in database.`, opts);
+}
+daemonCommand.command("run").option("--skip-resync", "Skip initial resync on startup").description("Run the file watcher in foreground for ALL registered projects").action(async (options) => {
+  const opts = getOutputOptions(daemonCommand);
+  const paths = getDaemonPaths();
+  process.on("uncaughtException", (err) => {
+    console.error(`[${(/* @__PURE__ */ new Date()).toISOString()}] FATAL: Uncaught exception:`);
+    console.error(err.stack || err.message);
+    writeCrashReport(err);
+    if (existsSync9(paths.pidFile)) {
+      try {
+        unlinkSync(paths.pidFile);
+      } catch {
+      }
+    }
     process.exit(1);
-  }
-  writeFileSync6(paths.pidFile, String(process.pid));
-  const watcher = createFileWatcher({
-    projectId: project.id,
-    projectPath: projectRoot,
-    useGitignore: true
   });
-  watcher.on("ready", (stats) => {
-    console.log(`[${(/* @__PURE__ */ new Date()).toISOString()}] Watcher ready - watching ${stats.filesWatched} files`);
+  process.on("unhandledRejection", (reason, promise) => {
+    console.error(`[${(/* @__PURE__ */ new Date()).toISOString()}] FATAL: Unhandled promise rejection:`);
+    console.error(reason);
+    writeCrashReport(reason);
+    if (existsSync9(paths.pidFile)) {
+      try {
+        unlinkSync(paths.pidFile);
+      } catch {
+      }
+    }
+    process.exit(1);
   });
-  watcher.on("sync", (event) => {
-    console.log(`[${(/* @__PURE__ */ new Date()).toISOString()}] Synced: ${event.type} ${event.path}`);
+  rotateLogIfNeeded();
+  writeFileSync6(paths.pidFile, String(process.pid));
+  console.log(`[${(/* @__PURE__ */ new Date()).toISOString()}] Starting AIGILE daemon for all registered projects...`);
+  console.log(`[${(/* @__PURE__ */ new Date()).toISOString()}] PID: ${process.pid}, Node: ${process.version}, Platform: ${platform()}`);
+  const manager = getDaemonManager();
+  if (!options.skipResync) {
+    console.log(`[${(/* @__PURE__ */ new Date()).toISOString()}] Performing initial resync for all projects...`);
+    try {
+      const results = await manager.resyncAll();
+      const projectCount = Object.keys(results).length;
+      console.log(`[${(/* @__PURE__ */ new Date()).toISOString()}] Resync complete: ${projectCount} projects synced`);
+    } catch (err) {
+      console.error(`[${(/* @__PURE__ */ new Date()).toISOString()}] Resync warning: ${err}`);
+    }
+  }
+  manager.on("sync", (event) => {
+    const categoryStr = event.category ? ` [${event.category}]` : "";
+    console.log(`[${(/* @__PURE__ */ new Date()).toISOString()}] [${event.project}] Synced: ${event.type} ${event.path}${categoryStr}`);
   });
-  watcher.on("syncError", ({ event, error: err }) => {
-    console.error(`[${(/* @__PURE__ */ new Date()).toISOString()}] Sync error: ${event.type} ${event.path} - ${err}`);
+  manager.on("syncError", ({ project, event, error: err }) => {
+    console.error(`[${(/* @__PURE__ */ new Date()).toISOString()}] [${project}] Sync error: ${event.type} ${event.path} - ${err}`);
   });
-  watcher.on("error", (err) => {
-    console.error(`[${(/* @__PURE__ */ new Date()).toISOString()}] Watcher error: ${err}`);
+  manager.on("watcherError", ({ project, error: err }) => {
+    console.error(`[${(/* @__PURE__ */ new Date()).toISOString()}] [${project}] Watcher error: ${err}`);
   });
+  let isShuttingDown = false;
   const shutdown = async () => {
+    if (isShuttingDown) return;
+    isShuttingDown = true;
     console.log(`[${(/* @__PURE__ */ new Date()).toISOString()}] Shutting down...`);
-    await watcher.stop();
-    if (existsSync7(paths.pidFile)) {
+    const forceExitTimeout = setTimeout(() => {
+      console.error(`[${(/* @__PURE__ */ new Date()).toISOString()}] Shutdown timeout (${SHUTDOWN_TIMEOUT_MS}ms) - forcing exit`);
+      if (existsSync9(paths.pidFile)) {
+        try {
+          unlinkSync(paths.pidFile);
+        } catch {
+        }
+      }
+      process.exit(1);
+    }, SHUTDOWN_TIMEOUT_MS);
+    try {
+      await manager.stop();
+    } catch (err) {
+      console.error(`[${(/* @__PURE__ */ new Date()).toISOString()}] Error during shutdown: ${err}`);
+    }
+    clearTimeout(forceExitTimeout);
+    if (existsSync9(paths.pidFile)) {
       unlinkSync(paths.pidFile);
     }
+    console.log(`[${(/* @__PURE__ */ new Date()).toISOString()}] Daemon stopped gracefully`);
     process.exit(0);
   };
   process.on("SIGTERM", shutdown);
   process.on("SIGINT", shutdown);
-  watcher.start();
-  console.log(`[${(/* @__PURE__ */ new Date()).toISOString()}] Starting file watcher for ${projectRoot}...`);
+  const logRotationInterval = setInterval(() => {
+    rotateLogIfNeeded();
+  }, 60 * 60 * 1e3);
+  process.on("exit", () => {
+    clearInterval(logRotationInterval);
+  });
+  try {
+    const status = await manager.start();
+    console.log(`[${(/* @__PURE__ */ new Date()).toISOString()}] Daemon started - watching ${status.watchingCount} projects`);
+    for (const p of status.projects) {
+      if (p.watching) {
+        console.log(`[${(/* @__PURE__ */ new Date()).toISOString()}]   \u2713 ${p.key}: ${p.path}`);
+      }
+    }
+  } catch (err) {
+    console.error(`[${(/* @__PURE__ */ new Date()).toISOString()}] Failed to start daemon: ${err}`);
+    if (existsSync9(paths.pidFile)) {
+      unlinkSync(paths.pidFile);
+    }
+    process.exit(1);
+  }
 });
 daemonCommand.command("logs").option("-n, --lines <number>", "Number of lines to show", "50").option("-f, --follow", "Follow log output").description("Show daemon logs").action((options) => {
   const opts = getOutputOptions(daemonCommand);
   const paths = getDaemonPaths();
-  if (!existsSync7(paths.logFile)) {
+  if (!existsSync9(paths.logFile)) {
     info("No log file found. Daemon may not have run yet.", opts);
     return;
   }
@@ -7838,15 +9320,547 @@ daemonCommand.command("logs").option("-n, --lines <number>", "Number of lines to
     }
   }
 });
+daemonCommand.command("resync").option("--project <key>", "Resync only a specific project").description("Perform a full resync of all files for all registered projects").action(async (options) => {
+  const opts = getOutputOptions(daemonCommand);
+  const manager = getDaemonManager();
+  if (options.project) {
+    info(`Resyncing project ${options.project}...`, opts);
+    try {
+      const result = await manager.resyncProject(options.project);
+      if (!result) {
+        error(`Project "${options.project}" not found or invalid.`, opts);
+        process.exit(1);
+      }
+      if (opts.json) {
+        console.log(JSON.stringify({
+          success: true,
+          data: {
+            project: options.project,
+            ...result
+          }
+        }));
+      } else {
+        success(`Resync complete for ${options.project}:`, opts);
+        console.log(`  Allow:   ${result.allow}`);
+        console.log(`  Deny:    ${result.deny}`);
+        console.log(`  Unknown: ${result.unknown}`);
+      }
+    } catch (err) {
+      error(`Resync failed: ${err}`, opts);
+      process.exit(1);
+    }
+    return;
+  }
+  info("Resyncing all registered projects...", opts);
+  info("This may take a while for large repositories.", opts);
+  try {
+    const results = await manager.resyncAll();
+    const projectKeys = Object.keys(results);
+    if (opts.json) {
+      console.log(JSON.stringify({
+        success: true,
+        data: {
+          projectCount: projectKeys.length,
+          projects: results
+        }
+      }));
+    } else {
+      success(`Resync complete: ${projectKeys.length} projects`, opts);
+      for (const [key, result] of Object.entries(results)) {
+        console.log(`  ${key}: ${result.allow} allow, ${result.unknown} unknown`);
+      }
+    }
+  } catch (err) {
+    error(`Resync failed: ${err}`, opts);
+    process.exit(1);
+  }
+});
+daemonCommand.command("review").option("--list", "Just list unknown files without interactive review").option("--auto", "Auto-suggest category based on extension").description("Review and classify unknown files").action((options) => {
+  const opts = getOutputOptions(daemonCommand);
+  const projectRoot = findProjectRoot();
+  if (!projectRoot) {
+    error('Not in an AIGILE project. Run "aigile init" first.', opts);
+    process.exit(1);
+  }
+  const config = loadProjectConfig(projectRoot);
+  if (!config) {
+    error("Could not load project config.", opts);
+    process.exit(1);
+  }
+  const project = queryOne("SELECT id FROM projects WHERE key = ?", [config.project.key]);
+  if (!project) {
+    error(`Project "${config.project.key}" not found in database.`, opts);
+    process.exit(1);
+  }
+  const unknownFiles = queryAll(`
+      SELECT id, path, extension, size_bytes, updated_at
+      FROM documents
+      WHERE project_id = ? AND monitoring_category = 'unknown' AND status != 'deleted'
+      ORDER BY path
+    `, [project.id]);
+  if (unknownFiles.length === 0) {
+    success("No unknown files to review! All files are classified.", opts);
+    return;
+  }
+  if (opts.json) {
+    console.log(JSON.stringify({
+      success: true,
+      data: {
+        count: unknownFiles.length,
+        files: unknownFiles
+      }
+    }));
+    return;
+  }
+  if (options.list) {
+    console.log(`
+\u{1F4CB} Unknown Files (${unknownFiles.length} total)
+`);
+    data(
+      unknownFiles.map((f) => ({
+        path: f.path,
+        extension: f.extension || "-",
+        size: formatBytes(f.size_bytes),
+        updated: getRelativeTime(f.updated_at)
+      })),
+      [
+        { header: "Path", key: "path", width: 60 },
+        { header: "Ext", key: "extension", width: 8 },
+        { header: "Size", key: "size", width: 10 },
+        { header: "Updated", key: "updated", width: 12 }
+      ],
+      opts
+    );
+    console.log('\nUse "aigile daemon allow <pattern>" or "aigile daemon deny <pattern>" to classify files.');
+    return;
+  }
+  console.log(`
+\u{1F4CB} Unknown Files (${unknownFiles.length} total)
+`);
+  console.log('Run "aigile daemon review --list" to see all files.');
+  console.log('Use "aigile daemon allow <pattern>" or "aigile daemon deny <pattern>" to classify.\n');
+  const sample = unknownFiles.slice(0, 10);
+  for (const file of sample) {
+    console.log(`  ${file.path} (.${file.extension || "no ext"})`);
+  }
+  if (unknownFiles.length > 10) {
+    console.log(`  ... and ${unknownFiles.length - 10} more files`);
+  }
+});
+function formatBytes(bytes) {
+  if (bytes < 1024) return `${bytes}B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)}KB`;
+  if (bytes < 1024 * 1024 * 1024) return `${(bytes / (1024 * 1024)).toFixed(1)}MB`;
+  return `${(bytes / (1024 * 1024 * 1024)).toFixed(1)}GB`;
+}
+
+// src/commands/file.ts
+init_connection();
+import { Command as Command21 } from "commander";
+import { readFileSync as readFileSync10, existsSync as existsSync10 } from "fs";
+import { join as join12, relative as relative4 } from "path";
+init_config();
+var fileCommand = new Command21("file").description("Shadow mode file analysis and management for brownfield projects");
+function getProjectContext(opts) {
+  const projectRoot = findProjectRoot();
+  if (!projectRoot) {
+    error('Not in an AIGILE project. Run "aigile init" first.', opts);
+    return null;
+  }
+  const config = loadProjectConfig(projectRoot);
+  if (!config) {
+    error("Could not load project config.", opts);
+    return null;
+  }
+  const project = queryOne(
+    "SELECT id FROM projects WHERE key = ?",
+    [config.project.key]
+  );
+  if (!project) {
+    error(`Project "${config.project.key}" not found in database.`, opts);
+    return null;
+  }
+  return { projectId: project.id, projectRoot, projectKey: config.project.key };
+}
+function formatDocForTable(doc) {
+  return {
+    path: doc.path,
+    module: doc.inferred_module ?? "-",
+    type: doc.file_type ?? doc.extension ?? "-",
+    analyzed: doc.analyzed_at ? "Yes" : "No",
+    confidence: doc.analysis_confidence ?? "-",
+    tldr: doc.meta_tldr ? doc.meta_tldr.length > 40 ? doc.meta_tldr.slice(0, 37) + "..." : doc.meta_tldr : "-"
+  };
+}
+fileCommand.command("analyze <path>").option("--tldr <tldr>", "One-line summary of file purpose").option("--module <module>", "Module this file belongs to").option("--component <component>", "Component within module").option("--type <type>", "File type: component|service|util|config|test|doc|style|data").option("--deps <deps>", "Dependencies (comma-separated)").option("--exports <exports>", "Exported functions/classes (comma-separated)").option("--complexity <n>", "Complexity score (1-10)", parseInt).option("--confidence <n>", "AI confidence in analysis (0-100)", parseInt).option("--notes <notes>", "Additional analysis notes").description("Add analysis metadata to a tracked file (shadow mode)").action((filePath, options) => {
+  const opts = getOutputOptions(fileCommand);
+  const ctx = getProjectContext(opts);
+  if (!ctx) {
+    process.exit(1);
+  }
+  const normalizedPath = filePath.startsWith("/") ? relative4(ctx.projectRoot, filePath) : filePath;
+  const doc = getDocumentWithAnalysis(ctx.projectId, normalizedPath);
+  if (!doc) {
+    const tracked = trackShadowFile(ctx.projectId, ctx.projectRoot, normalizedPath);
+    if (!tracked) {
+      error(`File not tracked. Run "aigile sync scan" or track with "aigile file track ${normalizedPath}"`, opts);
+      process.exit(1);
+    }
+  }
+  const analysis = {};
+  if (options.tldr) analysis.tldr = options.tldr;
+  if (options.module) analysis.module = options.module;
+  if (options.component) analysis.component = options.component;
+  if (options.type) analysis.fileType = options.type;
+  if (options.deps) analysis.dependencies = options.deps.split(",").map((s) => s.trim());
+  if (options.exports) analysis.exports = options.exports.split(",").map((s) => s.trim());
+  if (options.complexity) analysis.complexity = options.complexity;
+  if (options.confidence) analysis.confidence = options.confidence;
+  if (options.notes) analysis.notes = options.notes;
+  if (Object.keys(analysis).length === 0) {
+    error("No analysis options provided. Use --tldr, --module, --type, etc.", opts);
+    process.exit(1);
+  }
+  const updated = updateDocumentAnalysis(ctx.projectId, normalizedPath, analysis);
+  if (!updated) {
+    error(`Failed to update analysis for: ${normalizedPath}`, opts);
+    process.exit(1);
+  }
+  const updatedDoc = getDocumentWithAnalysis(ctx.projectId, normalizedPath);
+  if (opts.json) {
+    console.log(JSON.stringify({
+      success: true,
+      data: {
+        path: normalizedPath,
+        analyzed: true,
+        analyzedAt: updatedDoc?.analyzed_at,
+        metadata: {
+          tldr: updatedDoc?.meta_tldr,
+          module: updatedDoc?.inferred_module,
+          component: updatedDoc?.inferred_component,
+          type: updatedDoc?.file_type,
+          dependencies: updatedDoc?.meta_dependencies ? JSON.parse(updatedDoc.meta_dependencies) : null,
+          exports: updatedDoc?.exports ? JSON.parse(updatedDoc.exports) : null,
+          complexity: updatedDoc?.complexity_score,
+          confidence: updatedDoc?.analysis_confidence
+        }
+      }
+    }));
+  } else {
+    success(`Analysis added for: ${normalizedPath}`, opts);
+    if (updatedDoc?.meta_tldr) {
+      info(`TLDR: ${updatedDoc.meta_tldr}`, opts);
+    }
+  }
+});
+fileCommand.command("list").alias("ls").option("--unanalyzed", "Only files without analysis").option("--analyzed", "Only files with analysis").option("--low-confidence [threshold]", "Files with low confidence (default: <70)", "70").option("--module <module>", "Filter by inferred module").option("--type <type>", "Filter by file type").option("--shadow", "Only shadow mode files").option("--count", "Return count only").option("--limit <n>", "Limit results", "100").option("--offset <n>", "Pagination offset", "0").option("--format <format>", "Output format: table|paths|json", "table").description("List tracked files with analysis filters").action((options) => {
+  const opts = getOutputOptions(fileCommand);
+  const ctx = getProjectContext(opts);
+  if (!ctx) {
+    process.exit(1);
+  }
+  const limit = parseInt(options.limit, 10);
+  const offset = parseInt(options.offset, 10);
+  if (options.count) {
+    let count = 0;
+    if (options.unanalyzed) {
+      count = getUnanalyzedCount(ctx.projectId);
+    } else {
+      const docs = options.unanalyzed ? getUnanalyzedDocuments(ctx.projectId) : getAnalyzedDocuments(ctx.projectId);
+      count = docs.length;
+    }
+    if (opts.json) {
+      console.log(JSON.stringify({ success: true, data: { count } }));
+    } else {
+      console.log(count);
+    }
+    return;
+  }
+  let documents = [];
+  if (options.unanalyzed) {
+    documents = getUnanalyzedDocuments(ctx.projectId, limit, offset);
+  } else if (options.analyzed) {
+    documents = getAnalyzedDocuments(ctx.projectId, limit);
+  } else if (options.lowConfidence) {
+    const threshold = parseInt(options.lowConfidence, 10) || 70;
+    documents = getLowConfidenceDocuments(ctx.projectId, threshold);
+  } else if (options.module) {
+    documents = getDocumentsByInferredModule(ctx.projectId, options.module);
+  } else if (options.type) {
+    documents = getDocumentsByFileType(ctx.projectId, options.type);
+  } else if (options.shadow) {
+    documents = getShadowDocuments(ctx.projectId);
+  } else {
+    documents = getUnanalyzedDocuments(ctx.projectId, limit, offset);
+  }
+  if (opts.json || options.format === "json") {
+    console.log(JSON.stringify({
+      success: true,
+      data: documents.map((d) => ({
+        path: d.path,
+        filename: d.filename,
+        extension: d.extension,
+        module: d.inferred_module,
+        component: d.inferred_component,
+        fileType: d.file_type,
+        analyzed: !!d.analyzed_at,
+        analyzedAt: d.analyzed_at,
+        confidence: d.analysis_confidence,
+        tldr: d.meta_tldr,
+        dependencies: d.meta_dependencies ? JSON.parse(d.meta_dependencies) : null,
+        exports: d.exports ? JSON.parse(d.exports) : null,
+        complexity: d.complexity_score
+      }))
+    }));
+  } else if (options.format === "paths") {
+    documents.forEach((d) => console.log(d.path));
+  } else {
+    const displayDocs = documents.map(formatDocForTable);
+    data(
+      displayDocs,
+      [
+        { header: "Path", key: "path", width: 50 },
+        { header: "Module", key: "module", width: 15 },
+        { header: "Type", key: "type", width: 10 },
+        { header: "Analyzed", key: "analyzed", width: 8 },
+        { header: "Conf", key: "confidence", width: 5 }
+      ],
+      opts
+    );
+    info(`Showing ${documents.length} files`, opts);
+  }
+});
+fileCommand.command("progress").description("Show analysis progress statistics").action(() => {
+  const opts = getOutputOptions(fileCommand);
+  const ctx = getProjectContext(opts);
+  if (!ctx) {
+    process.exit(1);
+  }
+  const progress = getAnalysisProgress(ctx.projectId);
+  if (opts.json) {
+    console.log(JSON.stringify({ success: true, data: progress }));
+  } else {
+    const analyzedPct = progress.total > 0 ? Math.round(progress.analyzed / progress.total * 100) : 0;
+    console.log("\n\u{1F4CA} Analysis Progress\n");
+    console.log(`Total files:     ${progress.total}`);
+    console.log(`Analyzed:        ${progress.analyzed} (${analyzedPct}%)`);
+    console.log(`Unanalyzed:      ${progress.unanalyzed} (${100 - analyzedPct}%)`);
+    console.log(`Low confidence:  ${progress.lowConfidence}`);
+    const moduleEntries = Object.entries(progress.byModule);
+    if (moduleEntries.length > 0) {
+      console.log("\nBy module:");
+      for (const [module, stats] of moduleEntries) {
+        const pct = stats.total > 0 ? Math.round(stats.analyzed / stats.total * 100) : 0;
+        console.log(`  ${module}: ${stats.analyzed}/${stats.total} (${pct}%)`);
+      }
+    }
+    const typeEntries = Object.entries(progress.byFileType);
+    if (typeEntries.length > 0) {
+      console.log("\nBy file type:");
+      for (const [type, count] of typeEntries.slice(0, 10)) {
+        console.log(`  ${type}: ${count}`);
+      }
+    }
+    console.log("");
+  }
+});
+fileCommand.command("read <path>").option("--with-metadata", "Include existing DB metadata").option("--line-numbers", "Include line numbers").option("--limit <n>", "Limit number of lines", parseInt).description("Read file content (for AI agent analysis)").action((filePath, options) => {
+  const opts = getOutputOptions(fileCommand);
+  const ctx = getProjectContext(opts);
+  if (!ctx) {
+    process.exit(1);
+  }
+  const normalizedPath = filePath.startsWith("/") ? relative4(ctx.projectRoot, filePath) : filePath;
+  const fullPath = join12(ctx.projectRoot, normalizedPath);
+  if (!existsSync10(fullPath)) {
+    error(`File not found: ${normalizedPath}`, opts);
+    process.exit(1);
+  }
+  let content;
+  try {
+    content = readFileSync10(fullPath, "utf-8");
+  } catch {
+    error(`Could not read file: ${normalizedPath}`, opts);
+    process.exit(1);
+  }
+  let metadata;
+  if (options.withMetadata) {
+    metadata = getDocumentWithAnalysis(ctx.projectId, normalizedPath);
+  }
+  let lines = content.split("\n");
+  if (options.limit && options.limit > 0) {
+    lines = lines.slice(0, options.limit);
+  }
+  if (opts.json) {
+    console.log(JSON.stringify({
+      success: true,
+      data: {
+        path: normalizedPath,
+        content: lines.join("\n"),
+        lineCount: lines.length,
+        metadata: metadata ? {
+          tldr: metadata.meta_tldr,
+          module: metadata.inferred_module,
+          component: metadata.inferred_component,
+          fileType: metadata.file_type,
+          analyzed: !!metadata.analyzed_at,
+          confidence: metadata.analysis_confidence
+        } : null
+      }
+    }));
+  } else {
+    if (options.withMetadata && metadata) {
+      console.log(`# File: ${normalizedPath}`);
+      if (metadata.meta_tldr) console.log(`# TLDR: ${metadata.meta_tldr}`);
+      if (metadata.inferred_module) console.log(`# Module: ${metadata.inferred_module}`);
+      if (metadata.file_type) console.log(`# Type: ${metadata.file_type}`);
+      console.log("");
+    }
+    if (options.lineNumbers) {
+      lines.forEach((line, i) => {
+        console.log(`${String(i + 1).padStart(4)} | ${line}`);
+      });
+    } else {
+      console.log(lines.join("\n"));
+    }
+  }
+});
+fileCommand.command("track <path>").option("--type <type>", "File type classification").option("--module <module>", "Module assignment").option("--notes <notes>", "Initial notes").description("Track a file in shadow mode (brownfield)").action((filePath, options) => {
+  const opts = getOutputOptions(fileCommand);
+  const ctx = getProjectContext(opts);
+  if (!ctx) {
+    process.exit(1);
+  }
+  const normalizedPath = filePath.startsWith("/") ? relative4(ctx.projectRoot, filePath) : filePath;
+  const tracked = trackShadowFile(ctx.projectId, ctx.projectRoot, normalizedPath);
+  if (!tracked) {
+    error(`Could not track file: ${normalizedPath}`, opts);
+    process.exit(1);
+  }
+  if (options.type || options.module || options.notes) {
+    const analysis = {};
+    if (options.type) analysis.fileType = options.type;
+    if (options.module) analysis.module = options.module;
+    if (options.notes) analysis.notes = options.notes;
+    updateDocumentAnalysis(ctx.projectId, normalizedPath, analysis);
+  }
+  const doc = getDocumentWithAnalysis(ctx.projectId, normalizedPath);
+  if (opts.json) {
+    console.log(JSON.stringify({
+      success: true,
+      data: {
+        path: normalizedPath,
+        tracked: true,
+        shadowMode: true,
+        metadata: doc ? {
+          fileType: doc.file_type,
+          module: doc.inferred_module
+        } : null
+      }
+    }));
+  } else {
+    success(`Tracked in shadow mode: ${normalizedPath}`, opts);
+  }
+});
+fileCommand.command("show <path>").description("Show detailed file analysis").action((filePath) => {
+  const opts = getOutputOptions(fileCommand);
+  const ctx = getProjectContext(opts);
+  if (!ctx) {
+    process.exit(1);
+  }
+  const normalizedPath = filePath.startsWith("/") ? relative4(ctx.projectRoot, filePath) : filePath;
+  const doc = getDocumentWithAnalysis(ctx.projectId, normalizedPath);
+  if (!doc) {
+    error(`File not tracked: ${normalizedPath}`, opts);
+    process.exit(1);
+  }
+  if (opts.json) {
+    console.log(JSON.stringify({
+      success: true,
+      data: {
+        path: doc.path,
+        filename: doc.filename,
+        extension: doc.extension,
+        status: doc.status,
+        sizeBytes: doc.size_bytes,
+        lastScanned: doc.last_scanned_at,
+        hasFrontmatter: !!doc.has_frontmatter,
+        shadowMode: !!doc.shadow_mode,
+        analysis: {
+          analyzed: !!doc.analyzed_at,
+          analyzedAt: doc.analyzed_at,
+          confidence: doc.analysis_confidence,
+          tldr: doc.meta_tldr,
+          module: doc.inferred_module,
+          component: doc.inferred_component,
+          fileType: doc.file_type,
+          complexity: doc.complexity_score,
+          dependencies: doc.meta_dependencies ? JSON.parse(doc.meta_dependencies) : null,
+          exports: doc.exports ? JSON.parse(doc.exports) : null,
+          notes: doc.analysis_notes
+        }
+      }
+    }));
+  } else {
+    const displayData = {
+      path: doc.path,
+      filename: doc.filename,
+      extension: doc.extension,
+      status: doc.status,
+      size_bytes: doc.size_bytes,
+      last_scanned: doc.last_scanned_at,
+      shadow_mode: doc.shadow_mode ? "Yes" : "No",
+      analyzed: doc.analyzed_at ? "Yes" : "No",
+      analyzed_at: doc.analyzed_at ?? "-",
+      confidence: doc.analysis_confidence ?? "-",
+      tldr: doc.meta_tldr ?? "-",
+      module: doc.inferred_module ?? "-",
+      component: doc.inferred_component ?? "-",
+      file_type: doc.file_type ?? "-",
+      complexity: doc.complexity_score ?? "-",
+      dependencies: doc.meta_dependencies ? JSON.parse(doc.meta_dependencies).join(", ") : "-",
+      exports: doc.exports ? JSON.parse(doc.exports).join(", ") : "-",
+      notes: doc.analysis_notes ?? "-"
+    };
+    details(
+      displayData,
+      [
+        { label: "Path", key: "path" },
+        { label: "Filename", key: "filename" },
+        { label: "Extension", key: "extension" },
+        { label: "Status", key: "status" },
+        { label: "Size (bytes)", key: "size_bytes" },
+        { label: "Last Scanned", key: "last_scanned" },
+        { label: "Shadow Mode", key: "shadow_mode" },
+        { label: "Analyzed", key: "analyzed" },
+        { label: "Analyzed At", key: "analyzed_at" },
+        { label: "Confidence", key: "confidence" },
+        { label: "TLDR", key: "tldr" },
+        { label: "Module", key: "module" },
+        { label: "Component", key: "component" },
+        { label: "File Type", key: "file_type" },
+        { label: "Complexity", key: "complexity" },
+        { label: "Dependencies", key: "dependencies" },
+        { label: "Exports", key: "exports" },
+        { label: "Notes", key: "notes" }
+      ],
+      opts
+    );
+  }
+});
 
 // src/bin/aigile.ts
 async function main() {
-  const program = new Command21();
+  const program = new Command22();
   program.name("aigile").description("JIRA-compatible Agile project management CLI for AI-assisted development").version(VERSION, "-v, --version", "Display version number").option("--json", "Output in JSON format for machine parsing").option("--no-color", "Disable colored output");
   program.hook("preAction", async () => {
     await initDatabase();
   });
   program.hook("postAction", () => {
+    const args = process.argv.slice(2);
+    if (args[0] === "daemon" && args[1] === "run") {
+      return;
+    }
     closeDatabase();
   });
   program.addCommand(initCommand);
@@ -7869,6 +9883,7 @@ async function main() {
   program.addCommand(uxJourneyCommand);
   program.addCommand(docCommand);
   program.addCommand(daemonCommand);
+  program.addCommand(fileCommand);
   await program.parseAsync(process.argv);
 }
 main().catch((err) => {