@vladimir-ks/aigile 0.2.2 → 0.2.4

package/dist/bin/aigile.js

@@ -407,16 +407,26 @@ var init_config = __esm({
 // src/db/connection.ts
 var connection_exports = {};
 __export(connection_exports, {
+  assignFilesToChunk: () => assignFilesToChunk,
   closeDatabase: () => closeDatabase,
+  createChunk: () => createChunk,
+  flagFileQualityIssue: () => flagFileQualityIssue,
   generateId: () => generateId,
+  getChunk: () => getChunk,
+  getCoverageStats: () => getCoverageStats,
   getDatabase: () => getDatabase,
+  getFilesWithQualityIssues: () => getFilesWithQualityIssues,
   getNextKey: () => getNextKey,
+  getSessionChunks: () => getSessionChunks,
+  getSessionFiles: () => getSessionFiles,
+  getUntaggedFiles: () => getUntaggedFiles,
   initDatabase: () => initDatabase,
   queryAll: () => queryAll,
   queryOne: () => queryOne,
   run: () => run,
   runMigrations: () => runMigrations,
-  saveDatabase: () => saveDatabase
+  saveDatabase: () => saveDatabase,
+  tagFileReviewed: () => tagFileReviewed
 });
 import initSqlJs from "sql.js";
 import { existsSync as existsSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2, mkdirSync as mkdirSync2 } from "fs";
@@ -748,6 +758,7 @@ function initializeSchema(database) {
     CREATE TABLE IF NOT EXISTS sessions (
       id TEXT PRIMARY KEY,
       project_id TEXT REFERENCES projects(id),
+      name TEXT,
       started_at TEXT DEFAULT (datetime('now')),
       ended_at TEXT,
       summary TEXT,
@@ -789,6 +800,39 @@ function initializeSchema(database) {
       updated_at TEXT DEFAULT (datetime('now'))
     )
   `);
+  database.run(`
+    CREATE TABLE IF NOT EXISTS chunks (
+      id TEXT PRIMARY KEY,
+      session_id TEXT REFERENCES sessions(id),
+      name TEXT NOT NULL,
+      patterns TEXT,
+      assigned_files TEXT,
+      review_mode TEXT DEFAULT 'standard',
+      created_at TEXT DEFAULT (datetime('now')),
+      updated_at TEXT DEFAULT (datetime('now'))
+    )
+  `);
+  database.run(`
+    CREATE TABLE IF NOT EXISTS session_files (
+      id TEXT PRIMARY KEY,
+      session_id TEXT NOT NULL REFERENCES sessions(id),
+      document_id TEXT NOT NULL REFERENCES documents(id),
+      chunk_id TEXT REFERENCES chunks(id),
+      agent_id TEXT,
+      report_path TEXT,
+      reviewed_at TEXT NOT NULL DEFAULT (datetime('now')),
+      review_type TEXT DEFAULT 'assigned',
+      is_foundational INTEGER DEFAULT 0,
+      quality_issues TEXT,
+      created_at TEXT DEFAULT (datetime('now')),
+      UNIQUE(session_id, document_id)
+    )
+  `);
+  database.run(`CREATE INDEX IF NOT EXISTS idx_session_files_session ON session_files(session_id)`);
+  database.run(`CREATE INDEX IF NOT EXISTS idx_session_files_document ON session_files(document_id)`);
+  database.run(`CREATE INDEX IF NOT EXISTS idx_session_files_chunk ON session_files(chunk_id)`);
+  database.run(`CREATE INDEX IF NOT EXISTS idx_session_files_report ON session_files(report_path)`);
+  database.run(`CREATE INDEX IF NOT EXISTS idx_chunks_session ON chunks(session_id)`);
 }
 function generateId() {
   return randomUUID();
@@ -812,6 +856,194 @@ function getNextKey(projectKey) {
   }
   return `${projectKey}-${nextValue}`;
 }
+function createChunk(sessionId, chunkId, name, patterns, assignedFiles, reviewMode = "standard") {
+  run(
+    `INSERT INTO chunks (id, session_id, name, patterns, assigned_files, review_mode)
+     VALUES (?, ?, ?, ?, ?, ?)`,
+    [
+      chunkId,
+      sessionId,
+      name,
+      patterns ? JSON.stringify(patterns) : null,
+      assignedFiles ? JSON.stringify(assignedFiles) : null,
+      reviewMode
+    ]
+  );
+}
+function getChunk(chunkId) {
+  return queryOne("SELECT * FROM chunks WHERE id = ?", [chunkId]);
+}
+function getSessionChunks(sessionId) {
+  return queryAll(
+    "SELECT * FROM chunks WHERE session_id = ? ORDER BY created_at",
+    [sessionId]
+  );
+}
+function assignFilesToChunk(chunkId, files) {
+  const chunk = getChunk(chunkId);
+  if (!chunk) {
+    throw new Error(`Chunk "${chunkId}" not found`);
+  }
+  const existing = chunk.assigned_files ? JSON.parse(chunk.assigned_files) : [];
+  const merged = [.../* @__PURE__ */ new Set([...existing, ...files])];
+  run(
+    `UPDATE chunks SET assigned_files = ?, updated_at = datetime('now') WHERE id = ?`,
+    [JSON.stringify(merged), chunkId]
+  );
+}
+function tagFileReviewed(sessionId, documentId, options = {}) {
+  const existing = queryOne(
+    "SELECT id FROM session_files WHERE session_id = ? AND document_id = ?",
+    [sessionId, documentId]
+  );
+  if (existing) {
+    run(
+      `UPDATE session_files SET
+        chunk_id = COALESCE(?, chunk_id),
+        agent_id = COALESCE(?, agent_id),
+        report_path = COALESCE(?, report_path),
+        review_type = ?,
+        is_foundational = CASE WHEN ? = 1 THEN 1 ELSE is_foundational END,
+        reviewed_at = datetime('now')
+       WHERE id = ?`,
+      [
+        options.chunkId ?? null,
+        options.agentId ?? null,
+        options.reportPath ?? null,
+        options.reviewType ?? "assigned",
+        options.isFoundational ? 1 : 0,
+        existing.id
+      ]
+    );
+    return existing.id;
+  }
+  const id = generateId();
+  run(
+    `INSERT INTO session_files (id, session_id, document_id, chunk_id, agent_id, report_path, review_type, is_foundational)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?)`,
+    [
+      id,
+      sessionId,
+      documentId,
+      options.chunkId ?? null,
+      options.agentId ?? null,
+      options.reportPath ?? null,
+      options.reviewType ?? "assigned",
+      options.isFoundational ? 1 : 0
+    ]
+  );
+  return id;
+}
+function flagFileQualityIssue(sessionFileId, issues) {
+  const existing = queryOne(
+    "SELECT quality_issues FROM session_files WHERE id = ?",
+    [sessionFileId]
+  );
+  const current = existing?.quality_issues ? JSON.parse(existing.quality_issues) : [];
+  const merged = [.../* @__PURE__ */ new Set([...current, ...issues])];
+  run(
+    `UPDATE session_files SET quality_issues = ? WHERE id = ?`,
+    [JSON.stringify(merged), sessionFileId]
+  );
+}
+function getSessionFiles(sessionId, options = {}) {
+  let sql = "SELECT * FROM session_files WHERE session_id = ?";
+  const params = [sessionId];
+  if (options.chunkId) {
+    sql += " AND chunk_id = ?";
+    params.push(options.chunkId);
+  }
+  if (options.reviewType) {
+    sql += " AND review_type = ?";
+    params.push(options.reviewType);
+  }
+  if (options.foundationalOnly) {
+    sql += " AND is_foundational = 1";
+  }
+  return queryAll(sql, params);
+}
+function getFilesWithQualityIssues(sessionId) {
+  return queryAll(
+    `SELECT * FROM session_files
+     WHERE session_id = ? AND quality_issues IS NOT NULL AND quality_issues != '[]'`,
+    [sessionId]
+  );
+}
+function getUntaggedFiles(projectId, sessionId, options = {}) {
+  if (options.assignedOnly && options.chunkId) {
+    const chunk = getChunk(options.chunkId);
+    if (!chunk || !chunk.assigned_files) {
+      return [];
+    }
+    const assignedFiles = JSON.parse(chunk.assigned_files);
+    return queryAll(
+      `SELECT d.path, d.id as document_id
+       FROM documents d
+       WHERE d.project_id = ?
+       AND d.path IN (${assignedFiles.map(() => "?").join(",")})
+       AND d.id NOT IN (
+         SELECT sf.document_id FROM session_files sf WHERE sf.session_id = ?
+       )`,
+      [projectId, ...assignedFiles, sessionId]
+    );
+  }
+  return queryAll(
+    `SELECT d.path, d.id as document_id
+     FROM documents d
+     WHERE d.project_id = ?
+     AND d.id NOT IN (
+       SELECT sf.document_id FROM session_files sf WHERE sf.session_id = ?
+     )`,
+    [projectId, sessionId]
+  );
+}
+function getCoverageStats(sessionId, chunkId) {
+  const baseWhere = chunkId ? "WHERE session_id = ? AND chunk_id = ?" : "WHERE session_id = ?";
+  const params = chunkId ? [sessionId, chunkId] : [sessionId];
+  const assigned = queryOne(
+    `SELECT COUNT(*) as count FROM session_files ${baseWhere} AND review_type = 'assigned'`,
+    params
+  );
+  const explored = queryOne(
+    `SELECT COUNT(*) as count FROM session_files ${baseWhere} AND review_type = 'explored'`,
+    params
+  );
+  const foundational = queryOne(
+    `SELECT COUNT(*) as count FROM session_files ${baseWhere} AND is_foundational = 1`,
+    params
+  );
+  const skipped = queryOne(
+    `SELECT COUNT(*) as count FROM session_files ${baseWhere} AND review_type = 'skipped'`,
+    params
+  );
+  let assignedTotal = 0;
+  if (chunkId) {
+    const chunk = getChunk(chunkId);
+    if (chunk?.assigned_files) {
+      try {
+        assignedTotal = JSON.parse(chunk.assigned_files).length;
+      } catch {
+        assignedTotal = 0;
+      }
+    }
+  } else {
+    const chunks = getSessionChunks(sessionId);
+    for (const chunk of chunks) {
+      if (chunk.assigned_files) {
+        try {
+          assignedTotal += JSON.parse(chunk.assigned_files).length;
+        } catch {
+        }
+      }
+    }
+  }
+  return {
+    assigned: { total: assignedTotal, reviewed: assigned?.count ?? 0 },
+    explored: explored?.count ?? 0,
+    foundational: foundational?.count ?? 0,
+    skipped: skipped?.count ?? 0
+  };
+}
 function runMigrations() {
   const database = getDatabase();
   const columns = queryAll(
@@ -856,6 +1088,7 @@ function runMigrations() {
     CREATE TABLE IF NOT EXISTS sessions (
       id TEXT PRIMARY KEY,
       project_id TEXT REFERENCES projects(id),
+      name TEXT,
       started_at TEXT DEFAULT (datetime('now')),
       ended_at TEXT,
       summary TEXT,
@@ -864,6 +1097,10 @@ function runMigrations() {
       status TEXT DEFAULT 'active'
     )
   `);
+  try {
+    database.run(`ALTER TABLE sessions ADD COLUMN name TEXT`);
+  } catch {
+  }
   database.run(`
     CREATE TABLE IF NOT EXISTS activity_log (
       id TEXT PRIMARY KEY,
@@ -877,6 +1114,42 @@ function runMigrations() {
       timestamp TEXT DEFAULT (datetime('now'))
     )
   `);
+  database.run(`
+    CREATE TABLE IF NOT EXISTS chunks (
+      id TEXT PRIMARY KEY,
+      session_id TEXT REFERENCES sessions(id),
+      name TEXT NOT NULL,
+      patterns TEXT,
+      assigned_files TEXT,
+      review_mode TEXT DEFAULT 'standard',
+      created_at TEXT DEFAULT (datetime('now')),
+      updated_at TEXT DEFAULT (datetime('now'))
+    )
+  `);
+  database.run(`
+    CREATE TABLE IF NOT EXISTS session_files (
+      id TEXT PRIMARY KEY,
+      session_id TEXT NOT NULL REFERENCES sessions(id),
+      document_id TEXT NOT NULL REFERENCES documents(id),
+      chunk_id TEXT REFERENCES chunks(id),
+      agent_id TEXT,
+      report_path TEXT,
+      reviewed_at TEXT NOT NULL DEFAULT (datetime('now')),
+      review_type TEXT DEFAULT 'assigned',
+      is_foundational INTEGER DEFAULT 0,
+      quality_issues TEXT,
+      created_at TEXT DEFAULT (datetime('now')),
+      UNIQUE(session_id, document_id)
+    )
+  `);
+  try {
+    database.run(`CREATE INDEX IF NOT EXISTS idx_session_files_session ON session_files(session_id)`);
+    database.run(`CREATE INDEX IF NOT EXISTS idx_session_files_document ON session_files(document_id)`);
+    database.run(`CREATE INDEX IF NOT EXISTS idx_session_files_chunk ON session_files(chunk_id)`);
+    database.run(`CREATE INDEX IF NOT EXISTS idx_session_files_report ON session_files(report_path)`);
+    database.run(`CREATE INDEX IF NOT EXISTS idx_chunks_session ON chunks(session_id)`);
+  } catch {
+  }
   saveDatabase();
 }
 var db, dbPath;
@@ -890,10 +1163,10 @@ var init_connection = __esm({
 });
 
 // src/bin/aigile.ts
-import { Command as Command22 } from "commander";
+import { Command as Command23 } from "commander";
 
 // src/index.ts
-var VERSION = true ? "0.2.2" : "0.0.0-dev";
+var VERSION = true ? "0.2.4" : "0.0.0-dev";
 
 // src/bin/aigile.ts
 init_connection();
@@ -997,7 +1270,7 @@ function error(message, opts = {}) {
     console.error(`${prefix} ${message}`);
   }
 }
-function warning(message, opts = {}) {
+function warning2(message, opts = {}) {
   if (opts.json) {
     console.log(JSON.stringify({ warning: message }));
   } else {
@@ -1825,8 +2098,14 @@ function detectGitContext(targetPath) {
     relativePath
   };
 }
+var VALID_PROFILES = ["full-repo", "subrepo", "module"];
 function determineProfile(context, options, opts) {
   if (options.profile) {
+    if (!VALID_PROFILES.includes(options.profile)) {
+      throw new Error(
+        `Invalid profile "${options.profile}". Valid profiles: ${VALID_PROFILES.join(", ")}`
+      );
+    }
     return options.profile;
   }
   if (context.isSubmodule) {
@@ -1859,6 +2138,8 @@ function determineDbMode(profile, context, options) {
     case "module":
       const parentDbPath = findParentDb(context);
       return { mode: "shared", path: parentDbPath };
+    default:
+      return { mode: "local", path: ".aigile/aigile.db" };
   }
 }
 function findParentDb(context) {
@@ -2098,7 +2379,7 @@ projectCommand.command("list").alias("ls").description("List all registered proj
   console.log("  \u2713 = valid path, \u2717 = missing/invalid path");
   if (invalidCount > 0) {
     blank();
-    warning(`${invalidCount} project(s) have invalid paths. Run "aigile project cleanup" to remove.`, opts);
+    warning2(`${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) => {
@@ -2482,13 +2763,45 @@ epicCommand.command("transition").argument("<key>", "Epic key").argument("<statu
   run(`UPDATE epics SET status = ?, updated_at = datetime('now') WHERE key = ?`, [status, key]);
   success(`Epic "${key}" transitioned from "${epic.status}" to "${status}".`, opts);
 });
-epicCommand.command("delete").alias("rm").argument("<key>", "Epic key").option("--force", "Delete without confirmation").description("Delete epic").action((key) => {
+epicCommand.command("delete").alias("rm").argument("<key>", "Epic key").option("--force", "Delete and orphan child stories").option("--cascade", "Delete with all child stories and their tasks").description("Delete epic").action((key, options) => {
   const opts = getOutputOptions(epicCommand);
   const epic = queryOne("SELECT id FROM epics WHERE key = ?", [key]);
   if (!epic) {
     error(`Epic "${key}" not found.`, opts);
     process.exit(1);
   }
+  const childCount = queryOne(
+    "SELECT COUNT(*) as count FROM user_stories WHERE epic_id = ?",
+    [epic.id]
+  );
+  if (childCount && childCount.count > 0) {
+    if (!options.force && !options.cascade) {
+      error(
+        `Cannot delete epic "${key}": has ${childCount.count} child story(s). Use --force to orphan children, or --cascade to delete them.`,
+        opts
+      );
+      process.exit(1);
+    }
+    if (options.cascade) {
+      const taskCount = queryOne(
+        `SELECT COUNT(*) as count FROM tasks WHERE story_id IN
+           (SELECT id FROM user_stories WHERE epic_id = ?)`,
+        [epic.id]
+      );
+      warning2(
+        `Deleting ${childCount.count} child story(s) and ${taskCount?.count || 0} task(s)`,
+        opts
+      );
+      run(
+        `DELETE FROM tasks WHERE story_id IN (SELECT id FROM user_stories WHERE epic_id = ?)`,
+        [epic.id]
+      );
+      run("DELETE FROM user_stories WHERE epic_id = ?", [epic.id]);
+    } else {
+      warning2(`Orphaning ${childCount.count} child story(s)`, opts);
+      run("UPDATE user_stories SET epic_id = NULL WHERE epic_id = ?", [epic.id]);
+    }
+  }
   run("DELETE FROM epics WHERE key = ?", [key]);
   success(`Epic "${key}" deleted.`, opts);
 });
@@ -2664,13 +2977,33 @@ storyCommand.command("update").argument("<key>", "Story key").option("-s, --summ
   run(`UPDATE user_stories SET ${updates.join(", ")} WHERE key = ?`, params);
   success(`Story "${key}" updated.`, opts);
 });
-storyCommand.command("delete").alias("rm").argument("<key>", "Story key").option("--force", "Delete without confirmation").description("Delete story").action((key) => {
+storyCommand.command("delete").alias("rm").argument("<key>", "Story key").option("--force", "Delete and orphan child tasks").option("--cascade", "Delete with all child tasks").description("Delete story").action((key, options) => {
   const opts = getOutputOptions(storyCommand);
   const story = queryOne("SELECT id FROM user_stories WHERE key = ?", [key]);
   if (!story) {
     error(`Story "${key}" not found.`, opts);
     process.exit(1);
   }
+  const childCount = queryOne(
+    "SELECT COUNT(*) as count FROM tasks WHERE story_id = ?",
+    [story.id]
+  );
+  if (childCount && childCount.count > 0) {
+    if (!options.force && !options.cascade) {
+      error(
+        `Cannot delete story "${key}": has ${childCount.count} child task(s). Use --force to orphan children, or --cascade to delete them.`,
+        opts
+      );
+      process.exit(1);
+    }
+    if (options.cascade) {
+      warning2(`Deleting ${childCount.count} child task(s)`, opts);
+      run("DELETE FROM tasks WHERE story_id = ?", [story.id]);
+    } else {
+      warning2(`Orphaning ${childCount.count} child task(s)`, opts);
+      run("UPDATE tasks SET story_id = NULL WHERE story_id = ?", [story.id]);
+    }
+  }
   run("DELETE FROM user_stories WHERE key = ?", [key]);
   success(`Story "${key}" deleted.`, opts);
 });
@@ -4679,8 +5012,8 @@ syncCommand.command("comments").option("-t, --type <type>", "Filter by type (use
     params.push(options.type);
   }
   query += " ORDER BY d.path, dc.line_number";
-  const { queryAll: queryAll2 } = (init_connection(), __toCommonJS(connection_exports));
-  const comments = queryAll2(query, params);
+  const { queryAll: queryAll3 } = (init_connection(), __toCommonJS(connection_exports));
+  const comments = queryAll3(query, params);
   data(
     comments,
     [
@@ -4700,7 +5033,7 @@ init_config();
 
 // src/services/session-service.ts
 init_connection();
-function startSession(projectId) {
+function startSession(projectId, name) {
   const existing = queryOne(
     "SELECT id FROM sessions WHERE project_id = ? AND status = ?",
     [projectId, "active"]
@@ -4713,14 +5046,16 @@ function startSession(projectId) {
   }
   const sessionId = generateId();
   const now = (/* @__PURE__ */ new Date()).toISOString();
+  const sessionName = name || null;
   run(
-    `INSERT INTO sessions (id, project_id, started_at, status, entities_modified, files_modified)
-     VALUES (?, ?, ?, 'active', 0, 0)`,
-    [sessionId, projectId, now]
+    `INSERT INTO sessions (id, project_id, name, started_at, status, entities_modified, files_modified)
+     VALUES (?, ?, ?, ?, 'active', 0, 0)`,
+    [sessionId, projectId, sessionName, now]
   );
   return {
     id: sessionId,
     projectId,
+    name: sessionName,
     startedAt: now,
     endedAt: null,
     summary: null,
@@ -4772,6 +5107,86 @@ function getActiveSession(projectId) {
     status: session.status
   };
 }
+function getSessionByName(projectId, name) {
+  const session = queryOne(
+    "SELECT * FROM sessions WHERE project_id = ? AND name = ?",
+    [projectId, name]
+  );
+  if (!session) {
+    return null;
+  }
+  return {
+    id: session.id,
+    projectId: session.project_id,
+    name: session.name,
+    startedAt: session.started_at,
+    endedAt: session.ended_at,
+    summary: session.summary,
+    entitiesModified: session.entities_modified,
+    filesModified: session.files_modified,
+    status: session.status
+  };
+}
+function resumeSession(projectId, sessionId) {
+  const session = queryOne(
+    "SELECT * FROM sessions WHERE id = ? AND project_id = ?",
+    [sessionId, projectId]
+  );
+  if (!session) {
+    return null;
+  }
+  if (session.status === "completed") {
+    return null;
+  }
+  const existing = queryOne(
+    "SELECT id FROM sessions WHERE project_id = ? AND status = ? AND id != ?",
+    [projectId, "active", sessionId]
+  );
+  if (existing) {
+    run(
+      `UPDATE sessions SET status = 'abandoned', ended_at = datetime('now') WHERE id = ?`,
+      [existing.id]
+    );
+  }
+  run(
+    `UPDATE sessions SET status = 'active', ended_at = NULL WHERE id = ?`,
+    [sessionId]
+  );
+  return {
+    id: session.id,
+    projectId: session.project_id,
+    name: session.name,
+    startedAt: session.started_at,
+    endedAt: null,
+    summary: session.summary,
+    entitiesModified: session.entities_modified,
+    filesModified: session.files_modified,
+    status: "active"
+  };
+}
+function getSessionResumeInfo(sessionId) {
+  const chunks = getSessionChunks(sessionId);
+  let totalAssigned = 0;
+  for (const chunk of chunks) {
+    if (chunk.assigned_files) {
+      try {
+        totalAssigned += JSON.parse(chunk.assigned_files).length;
+      } catch {
+      }
+    }
+  }
+  const reviewed = queryOne(
+    `SELECT COUNT(*) as count FROM session_files WHERE session_id = ? AND review_type = 'assigned'`,
+    [sessionId]
+  );
+  return {
+    chunks,
+    coverage: {
+      total: totalAssigned,
+      reviewed: reviewed?.count ?? 0
+    }
+  };
+}
 function incrementSessionEntities(projectId, count = 1) {
   run(
     `UPDATE sessions SET entities_modified = entities_modified + ? WHERE project_id = ? AND status = 'active'`,
@@ -4956,7 +5371,7 @@ function getActivitySummary(projectId, since) {
 
 // src/commands/session.ts
 var sessionCommand = new Command11("session").description("Manage AI work sessions");
-sessionCommand.command("start").description("Start a new AI work session").action(() => {
+sessionCommand.command("start").argument("[name]", "Optional session name (e.g., init-241215-1030)").description("Start a new AI work session").action((name) => {
   const opts = getOutputOptions(sessionCommand);
   const projectRoot = findProjectRoot();
   if (!projectRoot) {
@@ -4973,17 +5388,21 @@ sessionCommand.command("start").description("Start a new AI work session").actio
     error(`Project "${config.project.key}" not found in database.`, opts);
     process.exit(1);
   }
-  const session = startSession(project.id);
+  const session = startSession(project.id, name);
   if (opts.json) {
     console.log(JSON.stringify({
       success: true,
       data: {
         sessionId: session.id,
+        name: session.name,
         startedAt: session.startedAt
       }
     }));
   } else {
     success(`Session started: ${session.id.slice(0, 8)}...`, opts);
+    if (session.name) {
+      info(`Name: ${session.name}`, opts);
+    }
     info(`Started at: ${session.startedAt}`, opts);
   }
 });
@@ -5258,6 +5677,109 @@ sessionCommand.command("activity").option("-t, --type <type>", "Filter by entity
     opts
   );
 });
+sessionCommand.command("find").argument("<name>", "Session name to search for").description("Find a session by name").action((name) => {
+  const opts = getOutputOptions(sessionCommand);
+  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 session = getSessionByName(project.id, name);
+  if (!session) {
+    error(`Session "${name}" not found.`, opts);
+    process.exit(1);
+  }
+  if (opts.json) {
+    console.log(JSON.stringify({
+      success: true,
+      data: {
+        id: session.id,
+        name: session.name,
+        status: session.status,
+        startedAt: session.startedAt,
+        endedAt: session.endedAt
+      }
+    }));
+  } else {
+    success(`Found session: ${session.id.slice(0, 8)}...`, opts);
+    console.log(`  Name: ${session.name}`);
+    console.log(`  Status: ${session.status}`);
+    console.log(`  Started: ${session.startedAt}`);
+    if (session.endedAt) {
+      console.log(`  Ended: ${session.endedAt}`);
+    }
+  }
+});
+sessionCommand.command("resume").argument("<name-or-id>", "Session name or ID to resume").description("Resume an incomplete session").action((nameOrId) => {
+  const opts = getOutputOptions(sessionCommand);
+  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);
+  }
+  let session = getSessionByName(project.id, nameOrId);
+  if (!session) {
+    session = getSession(nameOrId);
+  }
+  if (!session) {
+    error(`Session "${nameOrId}" not found.`, opts);
+    process.exit(1);
+  }
+  if (session.status === "completed") {
+    error(`Session "${nameOrId}" is already completed. Cannot resume.`, opts);
+    process.exit(1);
+  }
+  const resumed = resumeSession(project.id, session.id);
+  if (!resumed) {
+    error(`Failed to resume session "${nameOrId}".`, opts);
+    process.exit(1);
+  }
+  const resumeInfo = getSessionResumeInfo(session.id);
+  if (opts.json) {
+    console.log(JSON.stringify({
+      success: true,
+      data: {
+        id: resumed.id,
+        name: resumed.name,
+        status: resumed.status,
+        chunks: resumeInfo.chunks.length,
+        coverage: resumeInfo.coverage
+      }
+    }));
+  } else {
+    success(`Session resumed: ${resumed.id.slice(0, 8)}...`, opts);
+    if (resumed.name) {
+      console.log(`  Name: ${resumed.name}`);
+    }
+    console.log(`  Status: ${resumed.status}`);
+    console.log(`  Chunks: ${resumeInfo.chunks.length}`);
+    console.log(`  Coverage: ${resumeInfo.coverage.reviewed}/${resumeInfo.coverage.total} assigned files reviewed`);
+    if (resumeInfo.coverage.total > 0) {
+      const pct = Math.round(resumeInfo.coverage.reviewed / resumeInfo.coverage.total * 100);
+      console.log(`  Progress: ${pct}%`);
+    }
+  }
+});
 function calculateDuration2(start, end) {
   const startDate = new Date(start);
   const endDate = end ? new Date(end) : /* @__PURE__ */ new Date();
@@ -8964,7 +9486,7 @@ daemonCommand.command("install").description("Install daemon to start automatica
       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);
+      warning2("Service file created but could not enable. You may need to run:", opts);
       console.log(`  systemctl --user daemon-reload`);
       console.log(`  systemctl --user enable ${DAEMON_NAME}`);
     }
@@ -9456,9 +9978,11 @@ function formatBytes(bytes) {
 
 // src/commands/file.ts
 init_connection();
+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";
+import { glob } from "glob";
 init_config();
 var fileCommand = new Command21("file").description("Shadow mode file analysis and management for brownfield projects");
 function getProjectContext(opts) {
@@ -9848,10 +10372,721 @@ fileCommand.command("show <path>").description("Show detailed file analysis").ac
     );
   }
 });
+fileCommand.command("tag").argument("<path>", "File path to tag").option("--chunk <id>", "Chunk ID this file belongs to").option("--report <path>", "Report this file contributes to").option("--type <type>", "Review type: assigned|explored|skipped", "assigned").option("--foundational", "Mark as foundational file").option("--agent <id>", "Agent ID that reviewed this file").description("Tag a file as reviewed in the current session").action((filePath, options) => {
+  const opts = getOutputOptions(fileCommand);
+  const ctx = getProjectContext(opts);
+  if (!ctx) {
+    process.exit(1);
+  }
+  const session = getActiveSession(ctx.projectId);
+  if (!session) {
+    error('No active session. Start one with "aigile session start".', opts);
+    process.exit(1);
+  }
+  const normalizedPath = filePath.startsWith("/") ? relative4(ctx.projectRoot, filePath) : filePath;
+  const doc = queryOne(
+    "SELECT id FROM documents WHERE project_id = ? AND path = ?",
+    [ctx.projectId, normalizedPath]
+  );
+  if (!doc) {
+    const tracked = trackShadowFile(ctx.projectId, ctx.projectRoot, normalizedPath);
+    if (!tracked) {
+      error(`File not tracked: ${normalizedPath}. Run "aigile sync scan" first.`, opts);
+      process.exit(1);
+    }
+    const newDoc = queryOne(
+      "SELECT id FROM documents WHERE project_id = ? AND path = ?",
+      [ctx.projectId, normalizedPath]
+    );
+    if (!newDoc) {
+      error(`Could not track file: ${normalizedPath}`, opts);
+      process.exit(1);
+    }
+    doc.id = newDoc.id;
+  }
+  const validTypes = ["assigned", "explored", "skipped"];
+  if (!validTypes.includes(options.type)) {
+    error(`Invalid review type "${options.type}". Must be: ${validTypes.join(", ")}`, opts);
+    process.exit(1);
+  }
+  const sessionFileId = tagFileReviewed(session.id, doc.id, {
+    chunkId: options.chunk,
+    agentId: options.agent,
+    reportPath: options.report,
+    reviewType: options.type,
+    isFoundational: options.foundational ?? false
+  });
+  if (opts.json) {
+    console.log(JSON.stringify({
+      success: true,
+      data: {
+        session_file_id: sessionFileId,
+        path: normalizedPath,
+        session_id: session.id,
+        chunk_id: options.chunk ?? null,
+        review_type: options.type,
+        is_foundational: options.foundational ?? false
+      }
+    }));
+  } else {
+    success(`Tagged: ${normalizedPath}`, opts);
+    if (options.chunk) {
+      info(`  Chunk: ${options.chunk}`, opts);
+    }
+    info(`  Type: ${options.type}`, opts);
+  }
+});
+fileCommand.command("tag-batch").option("--chunk <id>", "Chunk ID for all files").option("--glob <pattern>", "Glob pattern for files").option("--type <type>", "Review type: assigned|explored|skipped", "assigned").option("--foundational", "Mark all as foundational").option("--agent <id>", "Agent ID").description("Tag multiple files as reviewed (from glob pattern or stdin)").action(async (options) => {
+  const opts = getOutputOptions(fileCommand);
+  const ctx = getProjectContext(opts);
+  if (!ctx) {
+    process.exit(1);
+  }
+  const session = getActiveSession(ctx.projectId);
+  if (!session) {
+    error('No active session. Start one with "aigile session start".', opts);
+    process.exit(1);
+  }
+  let filesToTag = [];
+  if (options.glob) {
+    const matches = await glob(options.glob, { cwd: ctx.projectRoot, nodir: true });
+    filesToTag = matches.map((f) => relative4(ctx.projectRoot, join12(ctx.projectRoot, f)));
+  } else {
+    error("Please provide --glob pattern. Stdin not supported yet.", opts);
+    process.exit(1);
+  }
+  if (filesToTag.length === 0) {
+    error("No files matched the pattern.", opts);
+    process.exit(1);
+  }
+  let tagged = 0;
+  let skipped = 0;
+  for (const filePath of filesToTag) {
+    const doc = queryOne(
+      "SELECT id FROM documents WHERE project_id = ? AND path = ?",
+      [ctx.projectId, filePath]
+    );
+    if (!doc) {
+      skipped++;
+      continue;
+    }
+    tagFileReviewed(session.id, doc.id, {
+      chunkId: options.chunk,
+      agentId: options.agent,
+      reviewType: options.type,
+      isFoundational: options.foundational ?? false
+    });
+    tagged++;
+  }
+  if (opts.json) {
+    console.log(JSON.stringify({
+      success: true,
+      data: { tagged, skipped, total: filesToTag.length }
+    }));
+  } else {
+    success(`Tagged ${tagged} files (${skipped} skipped - not tracked)`, opts);
+  }
+});
+fileCommand.command("untag").argument("<path>", "File path to untag").option("--session <id>", "Session ID (default: current)").description("Remove review tag from a file").action((filePath, options) => {
+  const opts = getOutputOptions(fileCommand);
+  const ctx = getProjectContext(opts);
+  if (!ctx) {
+    process.exit(1);
+  }
+  let sessionId = options.session;
+  if (!sessionId) {
+    const session = getActiveSession(ctx.projectId);
+    if (!session) {
+      error("No active session. Specify --session or start one.", opts);
+      process.exit(1);
+    }
+    sessionId = session.id;
+  }
+  const doc = queryOne(
+    "SELECT id FROM documents WHERE project_id = ? AND path = ?",
+    [ctx.projectId, filePath]
+  );
+  if (!doc) {
+    error(`File "${filePath}" not found in project.`, opts);
+    process.exit(1);
+  }
+  const existing = queryOne(
+    "SELECT id FROM session_files WHERE session_id = ? AND document_id = ?",
+    [sessionId, doc.id]
+  );
+  if (!existing) {
+    warning(`File "${filePath}" is not tagged in this session.`, opts);
+    return;
+  }
+  queryOne("DELETE FROM session_files WHERE id = ?", [existing.id]);
+  if (opts.json) {
+    console.log(JSON.stringify({
+      success: true,
+      data: { path: filePath, untagged: true }
+    }));
+  } else {
+    success(`Untagged: ${filePath}`, opts);
+  }
+});
+fileCommand.command("clear-tags").option("--session <id>", "Session ID (default: current)").option("--chunk <id>", "Only clear tags for specific chunk").option("--confirm", "Skip confirmation prompt").description("Remove all file tags from a session (for re-review)").action((options) => {
+  const opts = getOutputOptions(fileCommand);
+  const ctx = getProjectContext(opts);
+  if (!ctx) {
+    process.exit(1);
+  }
+  let sessionId = options.session;
+  if (!sessionId) {
+    const session = getActiveSession(ctx.projectId);
+    if (!session) {
+      error("No active session. Specify --session or start one.", opts);
+      process.exit(1);
+    }
+    sessionId = session.id;
+  }
+  let countQuery = "SELECT COUNT(*) as count FROM session_files WHERE session_id = ?";
+  const params = [sessionId];
+  if (options.chunk) {
+    countQuery += " AND chunk_id = ?";
+    params.push(options.chunk);
+  }
+  const result = queryOne(countQuery, params);
+  const count = result?.count ?? 0;
+  if (count === 0) {
+    warning("No tags to clear.", opts);
+    return;
+  }
+  if (!options.confirm && !opts.json) {
+    console.log(`This will remove ${count} tag(s).`);
+    console.log("Use --confirm to proceed.");
+    return;
+  }
+  let deleteQuery = "DELETE FROM session_files WHERE session_id = ?";
+  const deleteParams = [sessionId];
+  if (options.chunk) {
+    deleteQuery += " AND chunk_id = ?";
+    deleteParams.push(options.chunk);
+  }
+  queryOne(deleteQuery, deleteParams);
+  if (opts.json) {
+    console.log(JSON.stringify({
+      success: true,
+      data: { session_id: sessionId, cleared: count }
+    }));
+  } else {
+    success(`Cleared ${count} tag(s)`, opts);
+  }
+});
+fileCommand.command("untagged").option("--session <id>", "Session ID (default: current)").option("--chunk <id>", "Filter by chunk").option("--assigned-only", "Only show untagged assigned files").description("List files not yet tagged/reviewed in session").action((options) => {
+  const opts = getOutputOptions(fileCommand);
+  const ctx = getProjectContext(opts);
+  if (!ctx) {
+    process.exit(1);
+  }
+  let sessionId = options.session;
+  if (!sessionId) {
+    const session = getActiveSession(ctx.projectId);
+    if (!session) {
+      error("No active session. Specify --session or start one.", opts);
+      process.exit(1);
+    }
+    sessionId = session.id;
+  }
+  const untagged = getUntaggedFiles(ctx.projectId, sessionId, {
+    chunkId: options.chunk,
+    assignedOnly: options.assignedOnly
+  });
+  if (opts.json) {
+    console.log(JSON.stringify({
+      success: true,
+      data: {
+        session_id: sessionId,
+        chunk_id: options.chunk ?? null,
+        count: untagged.length,
+        files: untagged.map((f) => f.path)
+      }
+    }));
+  } else {
+    if (untagged.length === 0) {
+      success("All files have been tagged!", opts);
+      return;
+    }
+    console.log(`Untagged files (${untagged.length}):`);
+    for (const file of untagged) {
+      console.log(`  ${file.path}`);
+    }
+  }
+});
+fileCommand.command("coverage").option("--session <id>", "Session ID (default: current)").option("--by-chunk", "Group statistics by chunk").description("Show file review coverage statistics").action((options) => {
+  const opts = getOutputOptions(fileCommand);
+  const ctx = getProjectContext(opts);
+  if (!ctx) {
+    process.exit(1);
+  }
+  let sessionId = options.session;
+  if (!sessionId) {
+    const session = getActiveSession(ctx.projectId);
+    if (!session) {
+      error("No active session. Specify --session or start one.", opts);
+      process.exit(1);
+    }
+    sessionId = session.id;
+  }
+  if (options.byChunk) {
+    const chunks = getSessionChunks(sessionId);
+    if (chunks.length === 0) {
+      info("No chunks defined in this session.", opts);
+      return;
+    }
+    const chunkStats = chunks.map((chunk) => {
+      const stats = getCoverageStats(sessionId, chunk.id);
+      const pct = stats.assigned.total > 0 ? Math.round(stats.assigned.reviewed / stats.assigned.total * 100) : 100;
+      return {
+        id: chunk.id,
+        name: chunk.name,
+        assigned: `${stats.assigned.reviewed}/${stats.assigned.total} (${pct}%)`,
+        explored: stats.explored,
+        foundational: stats.foundational,
+        skipped: stats.skipped
+      };
+    });
+    if (opts.json) {
+      console.log(JSON.stringify({ success: true, data: chunkStats }));
+    } else {
+      data(
+        chunkStats,
+        [
+          { header: "ID", key: "id", width: 15 },
+          { header: "Name", key: "name", width: 20 },
+          { header: "Assigned", key: "assigned", width: 15 },
+          { header: "Explored", key: "explored", width: 10 },
+          { header: "Found.", key: "foundational", width: 8 },
+          { header: "Skipped", key: "skipped", width: 8 }
+        ],
+        opts
+      );
+    }
+  } else {
+    const stats = getCoverageStats(sessionId);
+    const totalTagged = getSessionFiles(sessionId).length;
+    const untagged = getUntaggedFiles(ctx.projectId, sessionId);
+    const total = totalTagged + untagged.length;
+    const pct = total > 0 ? Math.round(totalTagged / total * 100) : 100;
+    if (opts.json) {
+      console.log(JSON.stringify({
+        success: true,
+        data: {
+          session_id: sessionId,
+          total_files: total,
+          tagged: totalTagged,
+          untagged: untagged.length,
+          coverage_percent: pct,
+          by_type: {
+            assigned: stats.assigned.reviewed,
+            explored: stats.explored,
+            foundational: stats.foundational,
+            skipped: stats.skipped
+          }
+        }
+      }));
+    } else {
+      console.log(`
+Coverage for session ${sessionId.slice(0, 8)}...`);
+      console.log(`  Total files: ${total}`);
+      console.log(`  Tagged: ${totalTagged} (${pct}%)`);
+      console.log(`  Untagged: ${untagged.length}`);
+      console.log(`
+By type:`);
+      console.log(`  Assigned: ${stats.assigned.reviewed}`);
+      console.log(`  Explored: ${stats.explored}`);
+      console.log(`  Foundational: ${stats.foundational}`);
+      console.log(`  Skipped: ${stats.skipped}`);
+    }
+  }
+});
+fileCommand.command("flag").argument("<path>", "File path to flag").option("--duplicate <path>", "Similar/duplicate file").option("--unclear <lines>", 'Unclear code at lines (e.g., "45-60")').option("--note <text>", "Description of the issue").description("Flag a file with quality issues").action((filePath, options) => {
+  const opts = getOutputOptions(fileCommand);
+  const ctx = getProjectContext(opts);
+  if (!ctx) {
+    process.exit(1);
+  }
+  const session = getActiveSession(ctx.projectId);
+  if (!session) {
+    error('No active session. Start one with "aigile session start".', opts);
+    process.exit(1);
+  }
+  const normalizedPath = filePath.startsWith("/") ? relative4(ctx.projectRoot, filePath) : filePath;
+  const sessionFile = queryOne(
+    `SELECT sf.id FROM session_files sf
+       JOIN documents d ON sf.document_id = d.id
+       WHERE sf.session_id = ? AND d.path = ?`,
+    [session.id, normalizedPath]
+  );
+  if (!sessionFile) {
+    error(`File not tagged in this session: ${normalizedPath}. Tag it first with "aigile file tag".`, opts);
+    process.exit(1);
+  }
+  const issues = [];
+  if (options.duplicate) {
+    issues.push(`duplicate:${options.duplicate}`);
+  }
+  if (options.unclear) {
+    issues.push(`unclear:${options.unclear}`);
+  }
+  if (options.note) {
+    issues.push(`note:${options.note}`);
+  }
+  if (issues.length === 0) {
+    error("No issues specified. Use --duplicate, --unclear, or --note.", opts);
+    process.exit(1);
+  }
+  flagFileQualityIssue(sessionFile.id, issues);
+  if (opts.json) {
+    console.log(JSON.stringify({
+      success: true,
+      data: {
+        path: normalizedPath,
+        issues
+      }
+    }));
+  } else {
+    success(`Flagged: ${normalizedPath}`, opts);
+    for (const issue of issues) {
+      info(`  ${issue}`, opts);
+    }
+  }
+});
+fileCommand.command("duplicates").option("--session <id>", "Session ID (default: current)").description("List files flagged as duplicates").action((options) => {
+  const opts = getOutputOptions(fileCommand);
+  const ctx = getProjectContext(opts);
+  if (!ctx) {
+    process.exit(1);
+  }
+  let sessionId = options.session;
+  if (!sessionId) {
+    const session = getActiveSession(ctx.projectId);
+    if (!session) {
+      error("No active session. Specify --session or start one.", opts);
+      process.exit(1);
+    }
+    sessionId = session.id;
+  }
+  const filesWithIssues = getFilesWithQualityIssues(sessionId);
+  const duplicates = [];
+  for (const sf of filesWithIssues) {
+    if (!sf.quality_issues) continue;
+    const issues = JSON.parse(sf.quality_issues);
+    const doc = queryOne(
+      "SELECT path FROM documents WHERE id = ?",
+      [sf.document_id]
+    );
+    if (!doc) continue;
+    for (const issue of issues) {
+      if (issue.startsWith("duplicate:")) {
+        const duplicateOf = issue.replace("duplicate:", "");
+        const noteIssue = issues.find((i) => i.startsWith("note:"));
+        duplicates.push({
+          path: doc.path,
+          duplicate_of: duplicateOf,
+          note: noteIssue ? noteIssue.replace("note:", "") : void 0
+        });
+      }
+    }
+  }
+  if (opts.json) {
+    console.log(JSON.stringify({
+      success: true,
+      data: { duplicates }
+    }));
+  } else {
+    if (duplicates.length === 0) {
+      info("No duplicates flagged.", opts);
+      return;
+    }
+    console.log(`Flagged duplicates (${duplicates.length}):`);
+    for (const dup of duplicates) {
+      console.log(`  ${dup.path} <-> ${dup.duplicate_of}`);
+      if (dup.note) {
+        console.log(`    Note: ${dup.note}`);
+      }
+    }
+  }
+});
+fileCommand.command("issues").option("--session <id>", "Session ID (default: current)").description("List all files with quality issues").action((options) => {
+  const opts = getOutputOptions(fileCommand);
+  const ctx = getProjectContext(opts);
+  if (!ctx) {
+    process.exit(1);
+  }
+  let sessionId = options.session;
+  if (!sessionId) {
+    const session = getActiveSession(ctx.projectId);
+    if (!session) {
+      error("No active session. Specify --session or start one.", opts);
+      process.exit(1);
+    }
+    sessionId = session.id;
+  }
+  const filesWithIssues = getFilesWithQualityIssues(sessionId);
+  if (filesWithIssues.length === 0) {
+    info("No quality issues flagged.", opts);
+    return;
+  }
+  const issueList = [];
+  for (const sf of filesWithIssues) {
+    const doc = queryOne(
+      "SELECT path FROM documents WHERE id = ?",
+      [sf.document_id]
+    );
+    if (!doc) continue;
+    issueList.push({
+      path: doc.path,
+      issues: sf.quality_issues ? JSON.parse(sf.quality_issues) : []
+    });
+  }
+  if (opts.json) {
+    console.log(JSON.stringify({
+      success: true,
+      data: { files_with_issues: issueList }
+    }));
+  } else {
+    console.log(`Files with quality issues (${issueList.length}):`);
+    for (const file of issueList) {
+      console.log(`
+  ${file.path}:`);
+      for (const issue of file.issues) {
+        console.log(`    - ${issue}`);
+      }
+    }
+  }
+});
+
+// src/commands/chunk.ts
+init_connection();
+init_connection();
+import { Command as Command22 } from "commander";
+import { glob as glob2 } from "glob";
+import { relative as relative5, resolve as resolve2 } from "path";
+init_config();
+function safeParseArray(json) {
+  if (!json) return [];
+  try {
+    return JSON.parse(json);
+  } catch {
+    return [];
+  }
+}
+var chunkCommand = new Command22("chunk").description("Manage file review chunks for verified coverage");
+chunkCommand.command("create").argument("<id>", "Chunk ID (e.g., chunk-001)").option("-n, --name <name>", "Human-readable name").option("-p, --pattern <patterns...>", "Glob patterns for files").option("-a, --assign <files...>", "Explicit file assignments").option("-m, --mode <mode>", "Review mode: quick|standard|audit", "standard").description("Create a new chunk with file assignments").action(async (id, options) => {
+  const opts = getOutputOptions(chunkCommand);
+  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 session = getActiveSession(project.id);
+  if (!session) {
+    error('No active session. Start one with "aigile session start".', opts);
+    process.exit(1);
+  }
+  const existing = getChunk(id);
+  if (existing) {
+    error(`Chunk "${id}" already exists.`, opts);
+    process.exit(1);
+  }
+  const validModes = ["quick", "standard", "audit"];
+  if (!validModes.includes(options.mode)) {
+    error(`Invalid mode "${options.mode}". Must be: ${validModes.join(", ")}`, opts);
+    process.exit(1);
+  }
+  let assignedFiles = [];
+  if (options.pattern) {
+    for (const pattern of options.pattern) {
+      const matches = await glob2(pattern, { cwd: projectRoot, nodir: true });
+      assignedFiles.push(...matches.map((f) => relative5(projectRoot, resolve2(projectRoot, f))));
+    }
+  }
+  if (options.assign) {
+    assignedFiles.push(...options.assign);
+  }
+  assignedFiles = [...new Set(assignedFiles)];
+  const name = options.name ?? id;
+  createChunk(
+    session.id,
+    id,
+    name,
+    options.pattern ?? null,
+    assignedFiles.length > 0 ? assignedFiles : null,
+    options.mode
+  );
+  if (opts.json) {
+    console.log(JSON.stringify({
+      success: true,
+      data: {
+        id,
+        name,
+        patterns: options.pattern ?? [],
+        assigned_files: assignedFiles,
+        review_mode: options.mode,
+        session_id: session.id
+      }
+    }));
+  } else {
+    success(`Created chunk "${id}" (${name})`, opts);
+    if (assignedFiles.length > 0) {
+      console.log(`  Assigned files: ${assignedFiles.length}`);
+    }
+    if (options.pattern) {
+      console.log(`  Patterns: ${options.pattern.join(", ")}`);
+    }
+    console.log(`  Review mode: ${options.mode}`);
+  }
+});
+chunkCommand.command("files").argument("<id>", "Chunk ID").option("--json", "Output as JSON").description("List files assigned to a chunk").action((id) => {
+  const opts = getOutputOptions(chunkCommand);
+  const chunk = getChunk(id);
+  if (!chunk) {
+    error(`Chunk "${id}" not found.`, opts);
+    process.exit(1);
+  }
+  const assignedFiles = safeParseArray(chunk.assigned_files);
+  if (opts.json) {
+    console.log(JSON.stringify({
+      success: true,
+      data: {
+        chunk_id: id,
+        name: chunk.name,
+        patterns: safeParseArray(chunk.patterns),
+        files: assignedFiles,
+        review_mode: chunk.review_mode
+      }
+    }));
+  } else {
+    console.log(`Chunk: ${chunk.name} (${id})`);
+    console.log(`Review mode: ${chunk.review_mode}`);
+    console.log(`
+Assigned files (${assignedFiles.length}):`);
+    for (const file of assignedFiles) {
+      console.log(`  ${file}`);
+    }
+  }
+});
+chunkCommand.command("assign").argument("<id>", "Chunk ID").argument("<files...>", "Files to assign").description("Assign additional files to a chunk").action((id, files) => {
+  const opts = getOutputOptions(chunkCommand);
+  const chunk = getChunk(id);
+  if (!chunk) {
+    error(`Chunk "${id}" not found.`, opts);
+    process.exit(1);
+  }
+  try {
+    assignFilesToChunk(id, files);
+    if (opts.json) {
+      const updated = getChunk(id);
+      console.log(JSON.stringify({
+        success: true,
+        data: {
+          chunk_id: id,
+          added: files.length,
+          total: safeParseArray(updated.assigned_files).length
+        }
+      }));
+    } else {
+      success(`Assigned ${files.length} file(s) to chunk "${id}"`, opts);
+    }
+  } catch (err) {
+    error(err instanceof Error ? err.message : "Failed to assign files", opts);
+    process.exit(1);
+  }
+});
+chunkCommand.command("list").alias("ls").description("List all chunks in current session").action(() => {
+  const opts = getOutputOptions(chunkCommand);
+  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 session = getActiveSession(project.id);
+  if (!session) {
+    warning2("No active session.", opts);
+    return;
+  }
+  const chunks = getSessionChunks(session.id);
+  if (chunks.length === 0) {
+    warning2("No chunks defined in current session.", opts);
+    return;
+  }
+  data(
+    chunks.map((c) => ({
+      id: c.id,
+      name: c.name,
+      files: safeParseArray(c.assigned_files).length,
+      mode: c.review_mode,
+      created: c.created_at.split("T")[0]
+    })),
+    [
+      { header: "ID", key: "id", width: 15 },
+      { header: "Name", key: "name", width: 25 },
+      { header: "Files", key: "files", width: 8 },
+      { header: "Mode", key: "mode", width: 10 },
+      { header: "Created", key: "created", width: 12 }
+    ],
+    opts
+  );
+});
+chunkCommand.command("show").argument("<id>", "Chunk ID").description("Show chunk details").action((id) => {
+  const opts = getOutputOptions(chunkCommand);
+  const chunk = getChunk(id);
+  if (!chunk) {
+    error(`Chunk "${id}" not found.`, opts);
+    process.exit(1);
+  }
+  const assignedFiles = safeParseArray(chunk.assigned_files);
+  const patterns = safeParseArray(chunk.patterns);
+  details(
+    {
+      id: chunk.id,
+      name: chunk.name,
+      review_mode: chunk.review_mode,
+      patterns: patterns.length > 0 ? patterns.join(", ") : "-",
+      assigned_files: assignedFiles.length,
+      session_id: chunk.session_id.slice(0, 8) + "...",
+      created_at: chunk.created_at
+    },
+    [
+      { label: "ID", key: "id" },
+      { label: "Name", key: "name" },
+      { label: "Review Mode", key: "review_mode" },
+      { label: "Patterns", key: "patterns" },
+      { label: "Assigned Files", key: "assigned_files" },
+      { label: "Session", key: "session_id" },
+      { label: "Created", key: "created_at" }
+    ],
+    opts
+  );
+});
 
 // src/bin/aigile.ts
 async function main() {
-  const program = new Command22();
+  const program = new Command23();
   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();
@@ -9884,6 +11119,7 @@ async function main() {
   program.addCommand(docCommand);
   program.addCommand(daemonCommand);
   program.addCommand(fileCommand);
+  program.addCommand(chunkCommand);
   await program.parseAsync(process.argv);
 }
 main().catch((err) => {