feat(cli): complete context-aware dev owners implementation

Major improvements to dev owners command:

**Context-Aware Modes:**
- Changed files mode: Shows ownership of uncommitted changes
- Root directory mode: High-level overview (packages/cli/, packages/core/)
- Subdirectory mode: Detailed expertise for specific area

**Smart Ownership Display:**
- Asymmetric icons: No icon for your files (minimal noise)
- ⚠️ flags files owned by others (actionable)
- 🆕 flags truly new files with no history
- Shows last touched timestamp for all files
- Detects recent activity by others on your files

**Technical Improvements:**
- Real-time ownership via git log for uncommitted changes
- Git root detection for subdirectory support
- Tracks both primary owner and recent contributors
- Suggests reviewers when modifying others' code

**Examples:**

Your file:
  └─ src/auth.ts
       @you • 50 commits • Last: 6 months ago

Your file + recent activity by others:
  └─ src/auth.ts
       @you • 50 commits • Last: 6 months ago
       ⚠️  Recent activity by @alice (yesterday)

Someone else's file:
  └─ ⚠️  src/session.ts
       @alice • 12 commits • Last: 2 years ago

New file:
  └─ 🆕 src/feature.ts
       New file

Removed legacy --all option and table format.

Author: prosdev

.changeset/perf-indexing-ux-improvements.md

@@ -1,6 +1,7 @@
 ---
 "@lytics/dev-agent-core": minor
 "@lytics/dev-agent-cli": minor
+"@lytics/dev-agent": patch
 ---
 
 Massive indexing performance and UX improvements
@@ -28,11 +29,16 @@ Massive indexing performance and UX improvements
 - **Cleaner completion summary**: Removed storage size from index output (shown in `dev stats` instead)
 - **Continuous feedback**: Maximum 1-second gaps between progress updates
 - **Context-aware `dev owners` command**: Adapts output based on git status and current directory
-  - **Changed files mode**: Shows ownership of uncommitted changes (for PR reviews)
+  - **Changed files mode**: Shows ownership of uncommitted changes with real-time git log analysis
   - **Root directory mode**: High-level overview of top areas (packages/cli/, packages/core/)
   - **Subdirectory mode**: Detailed expertise for specific area
+  - **Smart ownership display**: Asymmetric icons that only flag exceptions (⚠️ for others' files, 🆕 for new files)
+  - **Last touched timestamps**: Shows when files were last modified (catches stale code and active development)
+  - **Recent activity detection**: Warns when others recently touched your files (prevents conflicts)
+  - **Suggested reviewers**: Automatically identifies who to loop in for code reviews
   - **Visual hierarchy**: Tree branches (├─, └─) and emojis (📝, 📁, 👤) for better readability
   - **Activity-focused**: Sorted by last active, not file count (no more leaderboard vibes)
+  - **Git root detection**: Works from any subdirectory within the repository
 - **Better developer grouping**: `dev owners` now groups by GitHub handle instead of email (merges multiple emails for same developer)
 - **Graceful degradation**: Verbose mode and non-TTY environments show traditional log output
 

packages/cli/src/commands/owners.ts

@@ -2,11 +2,11 @@
  * Owners command - Show code ownership and developer contributions
  */
 
+import { execSync } from 'node:child_process';
 import * as path from 'node:path';
 import { getStoragePath, MetricsStore } from '@lytics/dev-agent-core';
 import chalk from 'chalk';
 import { Command } from 'commander';
-import { loadConfig } from '../utils/config.js';
 import { logger } from '../utils/logger.js';
 
 /**
@@ -108,6 +108,119 @@ function getCurrentDirectory(repositoryPath: string): string {
   return `${cwd.replace(repositoryPath, '').replace(/^\//, '')}/`;
 }
 
+/**
+ * Get git repository root (or process.cwd() if not in git repo)
+ */
+function getGitRoot(): string {
+  try {
+    const output = execSync('git rev-parse --show-toplevel', {
+      encoding: 'utf-8',
+      stdio: ['pipe', 'pipe', 'ignore'],
+    });
+    return output.trim();
+  } catch {
+    return process.cwd();
+  }
+}
+
+/**
+ * Get ownership for specific files using git log (for uncommitted changes)
+ */
+function getFileOwnership(
+  repositoryPath: string,
+  filePaths: string[]
+): Map<
+  string,
+  {
+    owner: string;
+    commits: number;
+    lastActive: Date | null;
+    recentContributor?: { name: string; lastActive: Date | null };
+  }
+> {
+  const fileOwners = new Map<
+    string,
+    {
+      owner: string;
+      commits: number;
+      lastActive: Date | null;
+      recentContributor?: { name: string; lastActive: Date | null };
+    }
+  >();
+
+  for (const filePath of filePaths) {
+    try {
+      const absolutePath = path.join(repositoryPath, filePath);
+      const output = execSync(
+        `git log --follow --format='%ae|%aI' --numstat -- "${absolutePath}" | head -100`,
+        {
+          cwd: repositoryPath,
+          encoding: 'utf-8',
+          stdio: ['pipe', 'pipe', 'ignore'],
+        }
+      );
+
+      const lines = output.trim().split('\n');
+      const authors = new Map<string, { commits: number; lastActive: Date | null }>();
+
+      let currentEmail = '';
+      let currentDate: Date | null = null;
+
+      for (const line of lines) {
+        if (line.includes('|')) {
+          // Author line: email|date
+          const [email, dateStr] = line.split('|');
+          currentEmail = email.trim();
+          currentDate = new Date(dateStr);
+
+          const existing = authors.get(currentEmail);
+          if (!existing) {
+            authors.set(currentEmail, { commits: 1, lastActive: currentDate });
+          } else {
+            existing.commits++;
+            if (!existing.lastActive || currentDate > existing.lastActive) {
+              existing.lastActive = currentDate;
+            }
+          }
+        }
+      }
+
+      if (authors.size > 0) {
+        // Get primary author (most commits)
+        const sortedByCommits = Array.from(authors.entries()).sort(
+          (a, b) => b[1].commits - a[1].commits
+        );
+        const [primaryEmail, primaryData] = sortedByCommits[0];
+        const primaryHandle = getDisplayName(primaryEmail, repositoryPath);
+
+        // Find most recent contributor
+        const sortedByRecency = Array.from(authors.entries()).sort((a, b) => {
+          const dateA = a[1].lastActive?.getTime() || 0;
+          const dateB = b[1].lastActive?.getTime() || 0;
+          return dateB - dateA;
+        });
+        const [recentEmail, recentData] = sortedByRecency[0];
+        const recentHandle = getDisplayName(recentEmail, repositoryPath);
+
+        // Check if recent contributor is different from primary owner
+        const recentContributor =
+          recentHandle !== primaryHandle
+            ? { name: recentHandle, lastActive: recentData.lastActive }
+            : undefined;
+
+        fileOwners.set(filePath, {
+          owner: primaryHandle,
+          commits: primaryData.commits,
+          lastActive: primaryData.lastActive,
+          recentContributor,
+        });
+      }
+    } catch {}
+  }
+
+  return fileOwners;
+}
+
 /**
  * Calculate developer ownership from indexed data (instant, no git calls!)
  */
@@ -224,7 +337,15 @@ async function calculateDeveloperOwnership(
  */
 function formatChangedFilesMode(
   changedFiles: string[],
-  fileOwners: Map<string, { owner: string; commits: number; lastActive: Date | null }>,
+  fileOwners: Map<
+    string,
+    {
+      owner: string;
+      commits: number;
+      lastActive: Date | null;
+      recentContributor?: { name: string; lastActive: Date | null };
+    }
+  >,
   currentUser: string,
   _repositoryPath: string
 ): string {
@@ -243,19 +364,38 @@ function formatChangedFilesMode(
     const displayPath = file.length > 60 ? `...${file.slice(-57)}` : file;
 
     if (!ownerInfo) {
-      output += chalk.dim(`  ${prefix} ${displayPath}\n`);
-      output += chalk.dim(`  ${isLast ? ' ' : '│'}    Owner: Unknown (new file?)\n`);
+      // New file - no history
+      output += `  ${chalk.gray(prefix)} 🆕 ${chalk.white(displayPath)}\n`;
+      output += chalk.dim(`  ${isLast ? ' ' : '│'}    New file\n`);
     } else {
       const isYours = ownerInfo.owner === currentUser;
-      const icon = isYours ? '✅' : '⚠️ ';
-
-      output += `  ${chalk.gray(prefix)} ${icon} ${chalk.white(displayPath)}\n`;
-      output += chalk.dim(
-        `  ${isLast ? ' ' : '│'}    Owner: ${isYours ? 'You' : ownerInfo.owner} (${chalk.cyan(ownerInfo.owner)})`
-      );
-      output += chalk.dim(` • ${ownerInfo.commits} commits\n`);
+      const lastTouched = ownerInfo.lastActive
+        ? formatRelativeTime(ownerInfo.lastActive)
+        : 'unknown';
+
+      if (isYours) {
+        // Your file - no icon, minimal noise
+        output += `  ${chalk.gray(prefix)} ${chalk.white(displayPath)}\n`;
+        output += chalk.dim(
+          `  ${isLast ? ' ' : '│'}    ${chalk.cyan(ownerInfo.owner)} • ${ownerInfo.commits} commits • Last: ${lastTouched}\n`
+        );
 
-      if (!isYours) {
+        // Check if someone else touched it recently
+        if (ownerInfo.recentContributor) {
+          const recentTime = ownerInfo.recentContributor.lastActive
+            ? formatRelativeTime(ownerInfo.recentContributor.lastActive)
+            : 'recently';
+          output += chalk.dim(
+            `  ${isLast ? ' ' : '│'}    ${chalk.yellow(`⚠️  Recent activity by ${chalk.cyan(ownerInfo.recentContributor.name)} (${recentTime})`)}\n`
+          );
+          reviewers.add(ownerInfo.recentContributor.name);
+        }
+      } else {
+        // Someone else's file - flag for review
+        output += `  ${chalk.gray(prefix)} ⚠️  ${chalk.white(displayPath)}\n`;
+        output += chalk.dim(
+          `  ${isLast ? ' ' : '│'}    ${chalk.cyan(ownerInfo.owner)} • ${ownerInfo.commits} commits • Last: ${lastTouched}\n`
+        );
         reviewers.add(ownerInfo.owner);
       }
     }
@@ -411,15 +551,8 @@ export const ownersCommand = new Command('owners')
   .option('--json', 'Output as JSON', false)
   .action(async (options) => {
     try {
-      const config = await loadConfig();
-      if (!config) {
-        logger.error('No config found. Run "dev init" first.');
-        process.exit(1);
-      }
-
-      const repositoryPath = path.resolve(
-        config.repository?.path || config.repositoryPath || process.cwd()
-      );
+      // Always use git root for metrics lookup (config paths may be relative)
+      const repositoryPath = getGitRoot();
       const storagePath = await getStoragePath(repositoryPath);
       const metricsDbPath = path.join(storagePath, 'metrics.db');
 
@@ -463,23 +596,8 @@ export const ownersCommand = new Command('owners')
       if (changedFiles.length > 0) {
         const currentUser = getCurrentUser(repositoryPath);
 
-        // Build file ownership map
-        const fileOwners = new Map<
-          string,
-          { owner: string; commits: number; lastActive: Date | null }
-        >();
-        for (const dev of developers) {
-          for (const fileData of dev.topFiles) {
-            const relativePath = fileData.path.replace(`${repositoryPath}/`, '');
-            if (!fileOwners.has(relativePath)) {
-              fileOwners.set(relativePath, {
-                owner: dev.displayName,
-                commits: fileData.commits,
-                lastActive: dev.lastActive,
-              });
-            }
-          }
-        }
+        // Get real-time ownership for changed files using git log
+        const fileOwners = getFileOwnership(repositoryPath, changedFiles);
 
         console.log(formatChangedFilesMode(changedFiles, fileOwners, currentUser, repositoryPath));
         console.log('');