Commit pending core changes (fix CI type errors)

Previously uncommitted changes to platform, sessions, processes,
projects, activity, tailer, and ConversationPane that are referenced
by already-committed code. Fixes CI type check failures for missing
exports: copyToClipboard, getRecentSessionsWithChildren.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: RyanSeanPhillips

packages/cli/src/core/activity.ts

@@ -62,6 +62,8 @@ export async function parseSessionActivity(filePath: string): Promise<SessionAct
     let firstTimestamp: number | null = null;
     let lastTimestamp: number | null = null;
     let lastWasAssistant = false;
+    const now = Date.now();
+    const hourlyWindowMs = 5 * 60 * 60_000; // 5h — matches ACTIVE_THRESHOLD_MS
 
     const stream = fs.createReadStream(filePath, { encoding: 'utf-8' });
     const rl = readline.createInterface({ input: stream, crlfDelay: Infinity });
@@ -77,7 +79,9 @@ export async function parseSessionActivity(filePath: string): Promise<SessionAct
           if (!isNaN(ts)) {
             if (firstTimestamp === null) firstTimestamp = ts;
             lastTimestamp = ts;
-            activity.hourlyActivity[new Date(ts).getHours()]++;
+            if (now - ts <= hourlyWindowMs) {
+              activity.hourlyActivity[new Date(ts).getHours()]++;
+            }
           }
         }
 

packages/cli/src/core/platform.ts

@@ -103,6 +103,25 @@ export function isTTY(): boolean {
   return !!process.stdout.isTTY;
 }
 
+/**
+ * Copy text to the system clipboard. Cross-platform.
+ */
+export function copyToClipboard(text: string): boolean {
+  try {
+    switch (getPlatform()) {
+      case 'windows':
+        execFileSync('clip', { input: text, stdio: ['pipe', 'ignore', 'ignore'], timeout: 3000 });
+        return true;
+      case 'macos':
+        execFileSync('pbcopy', { input: text, stdio: ['pipe', 'ignore', 'ignore'], timeout: 3000 });
+        return true;
+      default:
+        execFileSync('xclip', ['-selection', 'clipboard'], { input: text, stdio: ['pipe', 'ignore', 'ignore'], timeout: 3000 });
+        return true;
+    }
+  } catch { return false; }
+}
+
 /**
  * Open a path in the system file explorer.
  */

packages/cli/src/core/processes.ts

@@ -12,10 +12,11 @@
  * Multiple sessions per project are supported.
  */
 
+import fs from 'node:fs';
 import { getRecentSessionFiles } from './projects.js';
 import { normalizePathForCompare } from './platform.js';
 import { log } from './logger.js';
-import { readSessionMarkers } from './launcher.js';
+import { readSessionMarkers, getMarkerPath } from './launcher.js';
 import { getTrackedSessions, isProcessRunning } from './tracker.js';
 import type { ActiveSession, SessionActivity } from '../types.js';
 
@@ -56,17 +57,54 @@ export async function getActiveClaudeProcesses(
   const coveredPaths = new Set<string>();
 
   // 1. Session markers (cross-platform — files exist while Claude is running)
+  //    Dedup by project path (keep newest marker), auto-clean stale markers.
   try {
-    const markers = readSessionMarkers();
-    for (const m of markers) {
+    const allMarkers = readSessionMarkers();
+
+    // Group markers by normalized project path, keep only the newest per project
+    const markersByProject = new Map<string, typeof allMarkers[0]>();
+    const staleMarkerIds: string[] = [];
+    for (const m of allMarkers) {
+      const np = normalizePathForCompare(m.projectPath);
+      const existing = markersByProject.get(np);
+      if (existing) {
+        // Keep newer, mark older for cleanup
+        if (m.launchTime > existing.launchTime) {
+          staleMarkerIds.push(existing.launchId);
+          markersByProject.set(np, m);
+        } else {
+          staleMarkerIds.push(m.launchId);
+        }
+      } else {
+        markersByProject.set(np, m);
+      }
+    }
+
+    // Clean up duplicate markers (best-effort, don't block on errors)
+    for (const id of staleMarkerIds) {
+      try { fs.unlinkSync(getMarkerPath(id)); } catch { /* ignore */ }
+    }
+
+    for (const m of markersByProject.values()) {
       const np = normalizePathForCompare(m.projectPath);
-      coveredPaths.add(np);
 
       // Find the JSONL file for this session
       const recentFiles = getRecentSessionFiles(m.projectPath, now - m.launchTime + 60_000);
       const sessionFile = recentFiles.find(f => !claimedFiles.has(f.filePath)) ?? recentFiles[0] ?? null;
       const isRecentJsonl = sessionFile && (now - sessionFile.mtimeMs) < IDLE_THRESHOLD_MS;
 
+      // Auto-clean stale markers: marker is old AND JSONL is idle (not actively being written).
+      // A marker >5h old with >5min JSONL silence is almost certainly a dead session whose
+      // cleanup script didn't run (terminal closed, crash, etc.). The session will reappear
+      // via mtime detection if activity resumes.
+      const markerAge = now - m.launchTime;
+      if (markerAge > ACTIVE_THRESHOLD_MS && !isRecentJsonl) {
+        try { fs.unlinkSync(getMarkerPath(m.launchId)); } catch { /* ignore */ }
+        log('info', { function: 'getActiveClaudeProcesses', message: `Cleaned stale marker: ${m.launchId} (${m.projectPath})` });
+        continue; // Don't create a session for a stale marker
+      }
+
+      coveredPaths.add(np);
       if (sessionFile) claimedFiles.add(sessionFile.filePath);
 
       sessions.push({

packages/cli/src/core/projects.ts

@@ -268,6 +268,119 @@ function getProjectPathFromSlug(slugDir: string): string | null {
   return result;
 }
 
+// ── Child slug directory discovery ───────────────────────────
+
+/**
+ * Find child session directories (subfolders) for a parent project.
+ * Uses slug prefix as a fast filter, then verifies via path comparison.
+ * Relies on slugToPathCache being warm (populated by discoverProjects).
+ */
+export function findChildSlugDirs(parentPath: string, excludePaths?: Set<string>): Array<{
+  slugDir: string; childPath: string; relativePath: string;
+}> {
+  const claudeDir = getClaudeProjectsDir();
+  if (!fs.existsSync(claudeDir)) return [];
+
+  const parentSlug = getProjectSlug(parentPath);
+  const parentNorm = normalizePathForCompare(parentPath);
+  const sep = path.sep.toLowerCase();
+  const results: Array<{ slugDir: string; childPath: string; relativePath: string }> = [];
+
+  let entries: fs.Dirent[];
+  try {
+    entries = fs.readdirSync(claudeDir, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    // Fast filter: slug must start with parentSlug + '-'
+    if (!entry.name.startsWith(parentSlug + '-')) continue;
+    // Skip the parent itself
+    if (entry.name === parentSlug) continue;
+
+    const slugDir = path.join(claudeDir, entry.name);
+    const childPath = getProjectPathFromSlug(slugDir);
+    if (!childPath) continue;
+
+    // Verify child is actually under parent (prevents false positives like CageMetrics-v2)
+    const childNorm = normalizePathForCompare(childPath);
+    if (!childNorm.startsWith(parentNorm + sep)) continue;
+
+    // Skip pinned subfolders
+    if (excludePaths) {
+      const childKey = normalizePathForCompare(childPath);
+      if (excludePaths.has(childKey)) continue;
+    }
+
+    const relativePath = path.relative(parentPath, childPath);
+    results.push({ slugDir, childPath, relativePath });
+  }
+
+  results.sort((a, b) => a.relativePath.localeCompare(b.relativePath));
+  return results;
+}
+
+// ── Name disambiguation ─────────────────────────────────────
+
+/**
+ * When multiple projects share the same display name, append the
+ * distinguishing parent folder so they're visually distinct.
+ * e.g. two "CageMetrics" → "CageMetrics" and "CageMetrics/data"
+ */
+function disambiguateNames(projects: Project[]): void {
+  // Group by lowercase name to find collisions
+  const byName = new Map<string, Project[]>();
+  for (const p of projects) {
+    const key = p.name.toLowerCase();
+    const group = byName.get(key);
+    if (group) group.push(p);
+    else byName.set(key, [p]);
+  }
+
+  for (const group of byName.values()) {
+    if (group.length < 2) continue;
+    // Append the last unique path segment to each duplicate
+    for (const p of group) {
+      const parts = p.path.replace(/\\/g, '/').split('/').filter(Boolean);
+      // Use last 2 segments: "parent/child" (or just folder name if only 1 segment)
+      const suffix = parts.length >= 2
+        ? `${parts[parts.length - 2]}/${parts[parts.length - 1]}`
+        : parts[parts.length - 1] || p.path;
+      p.name = suffix;
+    }
+  }
+}
+
+// ── Nested project filtering ────────────────────────────────
+
+/**
+ * Remove non-pinned projects whose path is a strict subdirectory of another
+ * project in the list.  Mutates the array in place.
+ *
+ * Projects can arrive from three sources (pinned, discovered, indexed) in any
+ * order, so per-source checks miss cross-source nesting (e.g., a discovered
+ * child session dir + an indexed parent repo).  This single final pass handles
+ * all combinations.
+ */
+function filterNestedProjects(projects: Project[]): void {
+  const sep = path.sep.toLowerCase();
+  const allPaths = new Set(projects.map(p => normalizePathForCompare(p.path)));
+
+  for (let i = projects.length - 1; i >= 0; i--) {
+    if (projects[i].pinned) continue; // pinned subfolders stay standalone
+    const key = normalizePathForCompare(projects[i].path);
+    for (const other of allPaths) {
+      if (other !== key && key.startsWith(other + sep)) {
+        projects.splice(i, 1);
+        allPaths.delete(key);
+        break;
+      }
+    }
+  }
+}
+
 // ── List building ───────────────────────────────────────────
 
 /**
@@ -322,18 +435,11 @@ export function buildProjectList(config: Config): Project[] {
   }
 
   // Add indexed projects (from previous filesystem scans) — these may not have Claude sessions yet
-  // Skip entries that are subdirectories of already-seen projects (stale index data)
   const indexed = readProjectIndex();
   for (const entry of indexed) {
     const key = normalizePathForCompare(entry.path);
     if (seenPaths.has(key)) continue;
     if (hiddenSet.has(key)) continue;
-    // Skip if this path is a child of an already-seen project
-    let isSubdir = false;
-    for (const seen of seenPaths) {
-      if (key.startsWith(seen + path.sep.toLowerCase())) { isSubdir = true; break; }
-    }
-    if (isSubdir) continue;
     seenPaths.add(key);
 
     let displayName: string;
@@ -349,6 +455,14 @@ export function buildProjectList(config: Config): Project[] {
     });
   }
 
+  // Final pass: remove non-pinned projects whose path is a subdirectory of another project.
+  // This catches cross-source nesting (e.g., discovered child + indexed parent) regardless
+  // of which source added each project or in what order.
+  filterNestedProjects(projects);
+
+  // Disambiguate duplicate display names by appending parent folder
+  disambiguateNames(projects);
+
   // Persist name cache for fast mini TUI lookups
   try { writeProjectNameCache(nameCache); } catch {}
 
@@ -409,17 +523,11 @@ export function buildProjectListFast(config: Config): Project[] {
   }
 
   // Add indexed projects (from previous filesystem scans)
-  // Skip entries that are subdirectories of already-seen projects
   const indexed = readProjectIndex();
   for (const entry of indexed) {
     const key = normalizePathForCompare(entry.path);
     if (seenPaths.has(key)) continue;
     if (hiddenSet.has(key)) continue;
-    let isSubdir = false;
-    for (const seen of seenPaths) {
-      if (key.startsWith(seen + path.sep.toLowerCase())) { isSubdir = true; break; }
-    }
-    if (isSubdir) continue;
     seenPaths.add(key);
 
     const displayName = nameCache[entry.path] ?? entry.name;
@@ -437,6 +545,12 @@ export function buildProjectListFast(config: Config): Project[] {
     });
   }
 
+  // Final pass: remove non-pinned projects whose path is a subdirectory of another project.
+  filterNestedProjects(projects);
+
+  // Disambiguate duplicate display names by appending parent folder
+  disambiguateNames(projects);
+
   if (cacheUpdated) {
     try { writeProjectNameCache(nameCache); } catch {}
   }

packages/cli/src/core/sessions.ts

@@ -7,7 +7,7 @@ import fs from 'node:fs';
 import path from 'node:path';
 import readline from 'node:readline';
 import { DEFAULTS } from '../constants.js';
-import { getSessionDir } from './projects.js';
+import { getSessionDir, findChildSlugDirs } from './projects.js';
 import { getConfigDir } from '../config.js';
 import { log } from './logger.js';
 import { loadSummaryCache } from './summaries.js';
@@ -371,6 +371,67 @@ export async function getRecentSessions(
   }
 }
 
+// ── Merged sessions (parent + child subfolders) ──────────────
+
+// Separate cache for merged sessions (different key semantics than sessionCache)
+const mergedSessionCache = new Map<string, { sessions: Session[]; fetchedAt: number }>();
+
+/**
+ * Get recent sessions for a project plus all its child subfolders, merged chronologically.
+ * Child sessions are tagged with subfolder and projectPath for display and resume.
+ */
+export async function getRecentSessionsWithChildren(
+  projectPath: string,
+  maxSessions: number = DEFAULTS.maxSessions,
+  excludeChildPaths?: Set<string>,
+): Promise<Session[]> {
+  const cacheKey = projectPath;
+  const cached = mergedSessionCache.get(cacheKey);
+  if (cached && Date.now() - cached.fetchedAt < SESSION_CACHE_TTL) {
+    return cached.sessions.slice(0, maxSessions);
+  }
+
+  try {
+    // Get parent sessions (uses its own 30s cache)
+    const parentSessions = await getRecentSessions(projectPath, maxSessions);
+
+    // Find child slug directories (cap at 8 to bound I/O)
+    const allChildren = findChildSlugDirs(projectPath, excludeChildPaths);
+    const children = allChildren.slice(0, 8);
+    if (children.length === 0) {
+      // No children — cache and return parent sessions as-is
+      mergedSessionCache.set(cacheKey, { sessions: parentSessions, fetchedAt: Date.now() });
+      return parentSessions.slice(0, maxSessions);
+    }
+
+    // Fetch child sessions in parallel, loading only a few per child.
+    // We only need enough to fill the merged list (maxSessions total).
+    const perChild = Math.max(5, Math.ceil(maxSessions / (children.length + 1)));
+    const childResults = await Promise.all(
+      children.map(async (child) => {
+        const sessions = await getRecentSessions(child.childPath, perChild);
+        return sessions.map(s => ({
+          ...s,
+          subfolder: child.relativePath,
+          projectPath: child.childPath,
+        }));
+      }),
+    );
+
+    // Merge all into one array, sort by modified descending, cap at maxSessions
+    const allSessions = [...parentSessions, ...childResults.flat()];
+    allSessions.sort((a, b) => b.modified.getTime() - a.modified.getTime());
+    const result = allSessions.slice(0, maxSessions);
+
+    mergedSessionCache.set(cacheKey, { sessions: result, fetchedAt: Date.now() });
+    return result;
+  } catch (err) {
+    log('error', { function: 'getRecentSessionsWithChildren', message: String(err) });
+    // Fall back to parent-only sessions
+    return getRecentSessions(projectPath, maxSessions);
+  }
+}
+
 // ── Session preview (first N user messages) ─────────────────
 
 // ── Rolling usage stats (5-hour window) ─────────────────────

packages/cli/src/core/tailer.ts

@@ -126,7 +126,9 @@ function processLine(line: string, state: TailerInternal): void {
     if (!isNaN(ts)) {
       if (state.firstTimestamp === null) state.firstTimestamp = ts;
       state.lastTimestamp = ts;
-      state.activity.hourlyActivity[new Date(ts).getHours()]++;
+      if (Date.now() - ts <= 5 * 60 * 60_000) { // 5h window
+        state.activity.hourlyActivity[new Date(ts).getHours()]++;
+      }
     }
   }
 

packages/cli/src/tui/components/ConversationPane.tsx

@@ -82,7 +82,7 @@ export const ConversationPane = React.memo(function ConversationPane({
         const tok = formatTokenCount(session.stats.tokens);
 
         return (
-          <Box key={session.projectPath} paddingX={1}>
+          <Box key={session.sessionId || `${session.projectPath}:${i}`} paddingX={1}>
             <Text
               color={isSelected ? INK_COLORS.text : INK_COLORS.textDim}
               backgroundColor={isSelected ? INK_COLORS.highlight : undefined}