groundcrew-cli 0.16.6 → 0.18.0

package/dist/index.js

@@ -4,6 +4,7 @@ import{createRequire}from'module';const require=createRequire(import.meta.url);
 import fs from "fs/promises";
 import { existsSync } from "fs";
 import path from "path";
+import os from "os";
 import readline from "readline";
 import { execFile, execFileSync } from "child_process";
 import { promisify } from "util";
@@ -73,35 +74,25 @@ close access fp`], { timeout: 3e3, stdio: ["pipe", "pipe", "pipe"] });
     return null;
   }
 }
-var GROUNDCREW_DIR = ".groundcrew";
-var SESSIONS_DIR = path.join(GROUNDCREW_DIR, "sessions");
-var ACTIVE_SESSIONS_FILE = path.join(GROUNDCREW_DIR, "active-sessions.json");
-var HISTORY_FILE = path.join(GROUNDCREW_DIR, "history.json");
+var GROUNDCREW_HOME = path.join(os.homedir(), ".groundcrew");
+var SESSIONS_DIR = path.join(GROUNDCREW_HOME, "sessions");
+var ACTIVE_SESSIONS_FILE = path.join(GROUNDCREW_HOME, "active-sessions.json");
+var HISTORY_FILE = path.join(GROUNDCREW_HOME, "history.json");
+var REPO_NAME = "";
 async function resolveRoot() {
-  let root = null;
+  let repoRoot = null;
   try {
-    const { stdout } = await execFileAsync("git", ["rev-parse", "--show-toplevel"]);
-    const gitRoot = stdout.trim();
-    if (gitRoot && existsSync(path.join(gitRoot, ".groundcrew"))) {
-      root = gitRoot;
+    const { stdout: gitCommonDir } = await execFileAsync("git", ["rev-parse", "--git-common-dir"]);
+    const trimmed = gitCommonDir.trim();
+    if (trimmed) {
+      const absGitDir = path.isAbsolute(trimmed) ? trimmed : path.resolve(process.cwd(), trimmed);
+      repoRoot = path.dirname(absGitDir);
     }
   } catch {
   }
-  if (!root) {
-    let dir = process.cwd();
-    while (dir !== path.dirname(dir)) {
-      if (existsSync(path.join(dir, ".groundcrew"))) {
-        root = dir;
-        break;
-      }
-      dir = path.dirname(dir);
-    }
-  }
-  if (!root) root = process.cwd();
-  GROUNDCREW_DIR = path.join(root, ".groundcrew");
-  SESSIONS_DIR = path.join(GROUNDCREW_DIR, "sessions");
-  ACTIVE_SESSIONS_FILE = path.join(GROUNDCREW_DIR, "active-sessions.json");
-  HISTORY_FILE = path.join(GROUNDCREW_DIR, "history.json");
+  if (!repoRoot) repoRoot = process.cwd();
+  REPO_NAME = path.basename(repoRoot).replace(/[^a-zA-Z0-9_-]/g, "_") || "unknown";
+  await fs.mkdir(SESSIONS_DIR, { recursive: true });
 }
 async function readActiveSessions() {
   try {
@@ -110,48 +101,60 @@ async function readActiveSessions() {
     return {};
   }
 }
+function isRepoSession(sessionId) {
+  return sessionId.startsWith(REPO_NAME + "-");
+}
 async function resolveSessionDir(explicitSession) {
   if (explicitSession) {
     const dir = path.join(SESSIONS_DIR, explicitSession);
-    if (!existsSync(dir)) {
-      throw new Error(`Session "${explicitSession}" not found.`);
-    }
-    return dir;
-  }
-  const sessions2 = await readActiveSessions();
-  const ids = Object.keys(sessions2);
-  if (ids.length === 0) {
+    if (existsSync(dir)) return dir;
     try {
-      const dirs = await fs.readdir(SESSIONS_DIR);
-      if (dirs.length === 1) return path.join(SESSIONS_DIR, dirs[0]);
-      if (dirs.length > 1) {
-        let latest2 = { dir: dirs[0], mtime: 0 };
-        for (const d of dirs) {
-          try {
-            const stat = await fs.stat(path.join(SESSIONS_DIR, d, "session.json"));
-            if (stat.mtimeMs > latest2.mtime) {
-              latest2 = { dir: d, mtime: stat.mtimeMs };
-            }
-          } catch {
-          }
-        }
-        return path.join(SESSIONS_DIR, latest2.dir);
-      }
+      const allDirs = await fs.readdir(SESSIONS_DIR);
+      const match = allDirs.find((d) => d.endsWith("-" + explicitSession));
+      if (match) return path.join(SESSIONS_DIR, match);
     } catch {
     }
-    throw new Error("No active sessions. Start Copilot with groundcrew first.");
+    throw new Error(`Session "${explicitSession}" not found.`);
   }
-  if (ids.length === 1) {
-    return path.join(SESSIONS_DIR, ids[0]);
+  const active = await readActiveSessions();
+  const repoIds = Object.keys(active).filter(isRepoSession);
+  if (repoIds.length === 1) return path.join(SESSIONS_DIR, repoIds[0]);
+  if (repoIds.length > 1) {
+    let latest = { id: repoIds[0], time: 0 };
+    for (const id of repoIds) {
+      const started = new Date(active[id].started).getTime();
+      if (started > latest.time) latest = { id, time: started };
+    }
+    return path.join(SESSIONS_DIR, latest.id);
   }
-  let latest = { id: ids[0], time: 0 };
-  for (const id of ids) {
-    const started = new Date(sessions2[id].started).getTime();
-    if (started > latest.time) {
-      latest = { id, time: started };
+  const allIds = Object.keys(active);
+  if (allIds.length === 1) return path.join(SESSIONS_DIR, allIds[0]);
+  if (allIds.length > 1) {
+    let latest = { id: allIds[0], time: 0 };
+    for (const id of allIds) {
+      const started = new Date(active[id].started).getTime();
+      if (started > latest.time) latest = { id, time: started };
     }
+    return path.join(SESSIONS_DIR, latest.id);
   }
-  return path.join(SESSIONS_DIR, latest.id);
+  try {
+    const dirs = await fs.readdir(SESSIONS_DIR);
+    const repoDirs = dirs.filter(isRepoSession);
+    const target = repoDirs.length > 0 ? repoDirs : dirs;
+    if (target.length >= 1) {
+      let latest = { dir: target[0], mtime: 0 };
+      for (const d of target) {
+        try {
+          const stat = await fs.stat(path.join(SESSIONS_DIR, d, "session.json"));
+          if (stat.mtimeMs > latest.mtime) latest = { dir: d, mtime: stat.mtimeMs };
+        } catch {
+        }
+      }
+      return path.join(SESSIONS_DIR, latest.dir);
+    }
+  } catch {
+  }
+  throw new Error("No active sessions. Start Copilot with groundcrew first.\n  Run 'groundcrew sessions' to see available sessions.");
 }
 function sessionQueueFile(sessionDir) {
   return path.join(sessionDir, "queue.json");
@@ -185,10 +188,6 @@ var cyan = (t) => color(36, t);
 var dim = (t) => color(2, t);
 var bold = (t) => color(1, t);
 var red = (t) => color(31, t);
-async function init() {
-  await fs.mkdir(SESSIONS_DIR, { recursive: true });
-  console.log(green("Groundcrew initialized.") + ` ${dim(GROUNDCREW_DIR + "/ created")}`);
-}
 async function add(taskText, priority, sessionDir) {
   const queue = await readQueue(sessionDir);
   const task = {
@@ -296,7 +295,7 @@ async function history(_sessionDir) {
     console.log();
   }
 }
-async function sessions() {
+async function sessions(filterRepo, filterStatus) {
   const active = await readActiveSessions();
   const ids = Object.keys(active);
   let allDirs = [];
@@ -308,23 +307,47 @@ async function sessions() {
     console.log(dim("No sessions found."));
     return;
   }
-  console.log(bold("Sessions:\n"));
+  const byRepo = /* @__PURE__ */ new Map();
   for (const dir of allDirs) {
-    const isActive = ids.includes(dir);
-    const sessionDir = path.join(SESSIONS_DIR, dir);
-    let info = "";
-    try {
-      const session = JSON.parse(await fs.readFile(path.join(sessionDir, "session.json"), "utf-8"));
-      const startTime = new Date(session.started).getTime();
-      const minutes = Math.round((Date.now() - startTime) / 6e4);
-      const statusColor = session.status === "active" ? green : session.status === "parked" ? yellow : dim;
-      info = `${statusColor(session.status)} | ${minutes}min | ${session.tasksCompleted || 0} tasks done`;
-    } catch {
-      info = dim("no session data");
+    const dashIdx = dir.lastIndexOf("-");
+    const repo = dashIdx > 0 ? dir.substring(0, dashIdx) : "unknown";
+    if (filterRepo && repo !== filterRepo) continue;
+    if (!byRepo.has(repo)) byRepo.set(repo, []);
+    byRepo.get(repo).push(dir);
+  }
+  if (byRepo.size === 0) {
+    console.log(dim(filterRepo ? `No sessions found for repo "${filterRepo}".` : "No sessions found."));
+    return;
+  }
+  console.log(bold("Sessions:\n"));
+  for (const [repo, dirs] of byRepo) {
+    const isCurrent = repo === REPO_NAME;
+    const repoEntries = [];
+    for (const dir of dirs) {
+      const isActive = ids.includes(dir);
+      const sessionDir = path.join(SESSIONS_DIR, dir);
+      let sessionStatus = "unknown";
+      let info = "";
+      try {
+        const session = JSON.parse(await fs.readFile(path.join(sessionDir, "session.json"), "utf-8"));
+        sessionStatus = session.status || "unknown";
+        const startTime = new Date(session.started).getTime();
+        const minutes = Math.round((Date.now() - startTime) / 6e4);
+        const statusColor = session.status === "active" ? green : session.status === "parked" ? yellow : dim;
+        info = `${statusColor(session.status)} | ${minutes}min | ${session.tasksCompleted || 0} tasks done`;
+      } catch {
+        info = dim("no session data");
+      }
+      if (filterStatus && sessionStatus !== filterStatus) continue;
+      const queue = await readQueue(sessionDir);
+      const marker = isActive ? green("*") : " ";
+      const shortId = dir.substring(repo.length + 1);
+      repoEntries.push(`    ${marker} ${cyan(shortId)}  ${info} | ${queue.tasks.length} queued`);
+    }
+    if (repoEntries.length > 0) {
+      console.log(`  ${isCurrent ? green(repo) : dim(repo)}`);
+      for (const entry of repoEntries) console.log(entry);
     }
-    const queue = await readQueue(sessionDir);
-    const marker = isActive ? green("*") : " ";
-    console.log(`  ${marker} ${cyan(dir)}  ${info} | ${queue.tasks.length} queued`);
   }
   if (ids.length > 0) {
     console.log(dim(`
@@ -381,14 +404,14 @@ async function destroyOne(sessionId) {
 }
 async function stopAll() {
   const active = await readActiveSessions();
-  const ids = Object.keys(active);
+  const ids = Object.keys(active).filter(isRepoSession);
   let allDirs = [];
   try {
-    allDirs = await fs.readdir(SESSIONS_DIR);
+    allDirs = (await fs.readdir(SESSIONS_DIR)).filter(isRepoSession);
   } catch {
   }
   if (ids.length === 0 && allDirs.length === 0) {
-    console.log(dim("No sessions to stop."));
+    console.log(dim(`No sessions to stop for repo "${REPO_NAME}".`));
     return;
   }
   for (const id of ids) {
@@ -404,31 +427,26 @@ async function stopAll() {
       console.log(`  ${green("cleaned")}  ${cyan(dir)} ${dim("(orphaned)")}`);
     }
   }
-  await fs.writeFile(ACTIVE_SESSIONS_FILE, "{}");
-  console.log(green("\nAll sessions stopped."));
+  const remaining = await readActiveSessions();
+  for (const id of ids) delete remaining[id];
+  await fs.writeFile(ACTIVE_SESSIONS_FILE, JSON.stringify(remaining, null, 2));
+  console.log(green(`
+All ${REPO_NAME} sessions stopped.`));
 }
 async function destroyAll() {
   await stopAll();
   try {
-    const dirs = await fs.readdir(SESSIONS_DIR);
+    const dirs = (await fs.readdir(SESSIONS_DIR)).filter(isRepoSession);
     for (const dir of dirs) {
       await fs.rm(path.join(SESSIONS_DIR, dir), { recursive: true, force: true });
     }
   } catch {
   }
   try {
-    await fs.unlink(HISTORY_FILE);
+    await fs.unlink(path.join(GROUNDCREW_HOME, "tool-history.csv"));
   } catch {
   }
-  try {
-    await fs.unlink(ACTIVE_SESSIONS_FILE);
-  } catch {
-  }
-  try {
-    await fs.unlink(path.join(GROUNDCREW_DIR, "tool-history.csv"));
-  } catch {
-  }
-  console.log(green("All session data and history deleted."));
+  console.log(green(`All ${REPO_NAME} session data deleted.`));
 }
 async function listSessionChoices() {
   const active = await readActiveSessions();
@@ -1116,7 +1134,6 @@ ${bold("groundcrew")} \u2014 CLI companion for the Groundcrew Copilot plugin
 ${bold("Usage:")}
   groundcrew chat                              Interactive chat mode (recommended)
   groundcrew chat --session <id>               Chat with a specific session
-  groundcrew init                              Initialize .groundcrew/ in current dir
   groundcrew add <task>                        Add a task to the queue
   groundcrew add --priority <task>             Add an urgent task (processed first)
   groundcrew add --session <id> <task>         Add to a specific session
@@ -1124,12 +1141,14 @@ ${bold("Usage:")}
   groundcrew feedback --session <id> <message> Send feedback to a specific session
   groundcrew queue                             List pending tasks
   groundcrew status                            Show session status and last update
-  groundcrew sessions                          List all sessions
+  groundcrew sessions                          List all sessions (all repos)
+  groundcrew sessions --repo mekari_credit     Filter by repo
+  groundcrew sessions --status active          Filter by status (active/parked/ended)
   groundcrew history                           Show completed tasks
   groundcrew clear                             Clear all pending tasks
-  groundcrew stop                              Stop all active sessions
+  groundcrew stop                              Stop all sessions for current repo
   groundcrew stop --session <id>               Stop a specific session
-  groundcrew destroy                           Delete all sessions, history, and data
+  groundcrew destroy                           Delete all sessions for current repo
   groundcrew destroy --session <id>            Delete a specific session
 
 ${bold("Session targeting:")}
@@ -1158,17 +1177,16 @@ function extractFlag(args, flag) {
 async function main() {
   await resolveRoot();
   const rawArgs = process.argv.slice(2);
-  const { value: explicitSession, remaining: args } = extractFlag(rawArgs, "--session");
+  const { value: explicitSession, remaining: args1 } = extractFlag(rawArgs, "--session");
+  const { value: filterRepo, remaining: args2 } = extractFlag(args1, "--repo");
+  const { value: filterStatus, remaining: args } = extractFlag(args2, "--status");
   const command = args[0];
   switch (command) {
-    case "init":
-      await init();
-      return;
     case "chat":
       await chat(explicitSession);
       return;
     case "sessions":
-      await sessions();
+      await sessions(filterRepo, filterStatus);
       return;
     case "history":
       await history();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "groundcrew-cli",
-  "version": "0.16.6",
+  "version": "0.18.0",
   "description": "CLI companion for Groundcrew — queue tasks, send feedback, monitor your Copilot agent from another terminal.",
   "type": "module",
   "bin": {

package/src/index.ts

@@ -1,6 +1,7 @@
 import fs from "fs/promises";
 import { existsSync } from "fs";
 import path from "path";
+import os from "os";
 import readline from "readline";
 import { execFile, execFileSync } from "child_process";
 import { promisify } from "util";
@@ -68,49 +69,38 @@ close access fp`], { timeout: 3000, stdio: ["pipe", "pipe", "pipe"] });
   } catch { return null; }
 }
 
-// Resolved at startup by resolveRoot() — git-aware project root discovery
-let GROUNDCREW_DIR = ".groundcrew";
-let SESSIONS_DIR = path.join(GROUNDCREW_DIR, "sessions");
-let ACTIVE_SESSIONS_FILE = path.join(GROUNDCREW_DIR, "active-sessions.json");
-let HISTORY_FILE = path.join(GROUNDCREW_DIR, "history.json");
+// ── Centralized storage at ~/.groundcrew ─────────────────────────────────────
+const GROUNDCREW_HOME = path.join(os.homedir(), ".groundcrew");
+const SESSIONS_DIR = path.join(GROUNDCREW_HOME, "sessions");
+const ACTIVE_SESSIONS_FILE = path.join(GROUNDCREW_HOME, "active-sessions.json");
+const HISTORY_FILE = path.join(GROUNDCREW_HOME, "history.json");
+
+let REPO_NAME = "";
 
 /**
- * Resolve the project root that contains .groundcrew/.
- * Uses git rev-parse --show-toplevel for worktree support, then walks up
- * from CWD as fallback. This ensures the CLI works from subdirectories
- * and git worktrees.
+ * Derive repo name from CWD. Uses git --git-common-dir to resolve through
+ * worktrees to the main repo root, so all worktrees share one session namespace.
  */
 async function resolveRoot(): Promise<void> {
-  let root: string | null = null;
+  let repoRoot: string | null = null;
 
-  // 1. Try git rev-parse --show-toplevel (worktree-aware)
+  // 1. Try git --git-common-dir (resolves worktrees to main repo)
   try {
-    const { stdout } = await execFileAsync("git", ["rev-parse", "--show-toplevel"]);
-    const gitRoot = stdout.trim();
-    if (gitRoot && existsSync(path.join(gitRoot, ".groundcrew"))) {
-      root = gitRoot;
+    const { stdout: gitCommonDir } = await execFileAsync("git", ["rev-parse", "--git-common-dir"]);
+    const trimmed = gitCommonDir.trim();
+    if (trimmed) {
+      const absGitDir = path.isAbsolute(trimmed) ? trimmed : path.resolve(process.cwd(), trimmed);
+      repoRoot = path.dirname(absGitDir);
     }
   } catch { /* not a git repo or git not installed */ }
 
-  // 2. Walk up from CWD looking for .groundcrew/
-  if (!root) {
-    let dir = process.cwd();
-    while (dir !== path.dirname(dir)) {
-      if (existsSync(path.join(dir, ".groundcrew"))) {
-        root = dir;
-        break;
-      }
-      dir = path.dirname(dir);
-    }
-  }
+  // 2. Fallback to CWD
+  if (!repoRoot) repoRoot = process.cwd();
 
-  // 3. Fallback to CWD (for `groundcrew init`)
-  if (!root) root = process.cwd();
+  REPO_NAME = path.basename(repoRoot).replace(/[^a-zA-Z0-9_-]/g, "_") || "unknown";
 
-  GROUNDCREW_DIR = path.join(root, ".groundcrew");
-  SESSIONS_DIR = path.join(GROUNDCREW_DIR, "sessions");
-  ACTIVE_SESSIONS_FILE = path.join(GROUNDCREW_DIR, "active-sessions.json");
-  HISTORY_FILE = path.join(GROUNDCREW_DIR, "history.json");
+  // Ensure centralized dirs exist
+  await fs.mkdir(SESSIONS_DIR, { recursive: true });
 }
 
 interface Task {
@@ -147,57 +137,78 @@ async function readActiveSessions(): Promise<Record<string, ActiveSessionEntry>>
   }
 }
 
+/**
+ * Filter session IDs that belong to the current repo.
+ * Session IDs are prefixed with repo name: "mekari_credit-a1b2c3d4"
+ */
+function isRepoSession(sessionId: string): boolean {
+  return sessionId.startsWith(REPO_NAME + "-");
+}
+
 /**
  * Resolve which session to target.
- * Priority: --session flag > single active session > error if ambiguous.
+ * Priority: --session flag > repo match > any active session > error.
  */
 async function resolveSessionDir(explicitSession?: string): Promise<string> {
   if (explicitSession) {
+    // Allow short hex suffix — find the full session ID
     const dir = path.join(SESSIONS_DIR, explicitSession);
-    if (!existsSync(dir)) {
-      throw new Error(`Session "${explicitSession}" not found.`);
-    }
-    return dir;
-  }
-
-  const sessions = await readActiveSessions();
-  const ids = Object.keys(sessions);
+    if (existsSync(dir)) return dir;
 
-  if (ids.length === 0) {
-    // Fallback: check if any session dirs exist (server may have exited without cleanup)
+    // Try matching as suffix
     try {
-      const dirs = await fs.readdir(SESSIONS_DIR);
-      if (dirs.length === 1) return path.join(SESSIONS_DIR, dirs[0]);
-      if (dirs.length > 1) {
-        // Pick most recently modified
-        let latest = { dir: dirs[0], mtime: 0 };
-        for (const d of dirs) {
-          try {
-            const stat = await fs.stat(path.join(SESSIONS_DIR, d, "session.json"));
-            if (stat.mtimeMs > latest.mtime) {
-              latest = { dir: d, mtime: stat.mtimeMs };
-            }
-          } catch { /* skip */ }
-        }
-        return path.join(SESSIONS_DIR, latest.dir);
-      }
-    } catch { /* no sessions dir */ }
-    throw new Error("No active sessions. Start Copilot with groundcrew first.");
+      const allDirs = await fs.readdir(SESSIONS_DIR);
+      const match = allDirs.find((d) => d.endsWith("-" + explicitSession));
+      if (match) return path.join(SESSIONS_DIR, match);
+    } catch {}
+
+    throw new Error(`Session "${explicitSession}" not found.`);
   }
 
-  if (ids.length === 1) {
-    return path.join(SESSIONS_DIR, ids[0]);
+  const active = await readActiveSessions();
+
+  // 1. Try sessions for current repo first
+  const repoIds = Object.keys(active).filter(isRepoSession);
+  if (repoIds.length === 1) return path.join(SESSIONS_DIR, repoIds[0]);
+  if (repoIds.length > 1) {
+    let latest = { id: repoIds[0], time: 0 };
+    for (const id of repoIds) {
+      const started = new Date(active[id].started).getTime();
+      if (started > latest.time) latest = { id, time: started };
+    }
+    return path.join(SESSIONS_DIR, latest.id);
   }
 
-  // Multiple sessions — pick latest
-  let latest = { id: ids[0], time: 0 };
-  for (const id of ids) {
-    const started = new Date(sessions[id].started).getTime();
-    if (started > latest.time) {
-      latest = { id, time: started };
+  // 2. Fall back to ANY active session
+  const allIds = Object.keys(active);
+  if (allIds.length === 1) return path.join(SESSIONS_DIR, allIds[0]);
+  if (allIds.length > 1) {
+    let latest = { id: allIds[0], time: 0 };
+    for (const id of allIds) {
+      const started = new Date(active[id].started).getTime();
+      if (started > latest.time) latest = { id, time: started };
     }
+    return path.join(SESSIONS_DIR, latest.id);
   }
-  return path.join(SESSIONS_DIR, latest.id);
+
+  // 3. Check dirs on disk
+  try {
+    const dirs = await fs.readdir(SESSIONS_DIR);
+    const repoDirs = dirs.filter(isRepoSession);
+    const target = repoDirs.length > 0 ? repoDirs : dirs;
+    if (target.length >= 1) {
+      let latest = { dir: target[0], mtime: 0 };
+      for (const d of target) {
+        try {
+          const stat = await fs.stat(path.join(SESSIONS_DIR, d, "session.json"));
+          if (stat.mtimeMs > latest.mtime) latest = { dir: d, mtime: stat.mtimeMs };
+        } catch {}
+      }
+      return path.join(SESSIONS_DIR, latest.dir);
+    }
+  } catch {}
+
+  throw new Error("No active sessions. Start Copilot with groundcrew first.\n  Run 'groundcrew sessions' to see available sessions.");
 }
 
 function sessionQueueFile(sessionDir: string): string {
@@ -244,11 +255,6 @@ const red = (t: string) => color(31, t);
 
 // ── Commands ──────────────────────────────────────────────────────────────────
 
-async function init(): Promise<void> {
-  await fs.mkdir(SESSIONS_DIR, { recursive: true });
-  console.log(green("Groundcrew initialized.") + ` ${dim(GROUNDCREW_DIR + "/ created")}`);
-}
-
 async function add(taskText: string, priority: number, sessionDir: string): Promise<void> {
   const queue = await readQueue(sessionDir);
   const task: Task = {
@@ -382,11 +388,11 @@ async function history(_sessionDir?: string): Promise<void> {
   }
 }
 
-async function sessions(): Promise<void> {
+async function sessions(filterRepo?: string, filterStatus?: string): Promise<void> {
   const active = await readActiveSessions();
   const ids = Object.keys(active);
 
-  // Also check for session dirs that may not be in active-sessions.json
+  // All session dirs on disk
   let allDirs: string[] = [];
   try {
     allDirs = await fs.readdir(SESSIONS_DIR);
@@ -397,27 +403,61 @@ async function sessions(): Promise<void> {
     return;
   }
 
+  // Group by repo prefix
+  const byRepo = new Map<string, string[]>();
+  for (const dir of allDirs) {
+    const dashIdx = dir.lastIndexOf("-");
+    const repo = dashIdx > 0 ? dir.substring(0, dashIdx) : "unknown";
+
+    // Apply --repo filter
+    if (filterRepo && repo !== filterRepo) continue;
+
+    if (!byRepo.has(repo)) byRepo.set(repo, []);
+    byRepo.get(repo)!.push(dir);
+  }
+
+  if (byRepo.size === 0) {
+    console.log(dim(filterRepo ? `No sessions found for repo "${filterRepo}".` : "No sessions found."));
+    return;
+  }
+
   console.log(bold("Sessions:\n"));
 
-  for (const dir of allDirs) {
-    const isActive = ids.includes(dir);
-    const sessionDir = path.join(SESSIONS_DIR, dir);
+  for (const [repo, dirs] of byRepo) {
+    const isCurrent = repo === REPO_NAME;
+    const repoEntries: string[] = [];
 
-    let info = "";
-    try {
-      const session = JSON.parse(await fs.readFile(path.join(sessionDir, "session.json"), "utf-8"));
-      const startTime = new Date(session.started).getTime();
-      const minutes = Math.round((Date.now() - startTime) / 60000);
-      const statusColor = session.status === "active" ? green : session.status === "parked" ? yellow : dim;
-      info = `${statusColor(session.status)} | ${minutes}min | ${session.tasksCompleted || 0} tasks done`;
-    } catch {
-      info = dim("no session data");
-    }
+    for (const dir of dirs) {
+      const isActive = ids.includes(dir);
+      const sessionDir = path.join(SESSIONS_DIR, dir);
+
+      let sessionStatus = "unknown";
+      let info = "";
+      try {
+        const session = JSON.parse(await fs.readFile(path.join(sessionDir, "session.json"), "utf-8"));
+        sessionStatus = session.status || "unknown";
+        const startTime = new Date(session.started).getTime();
+        const minutes = Math.round((Date.now() - startTime) / 60000);
+        const statusColor = session.status === "active" ? green : session.status === "parked" ? yellow : dim;
+        info = `${statusColor(session.status)} | ${minutes}min | ${session.tasksCompleted || 0} tasks done`;
+      } catch {
+        info = dim("no session data");
+      }
+
+      // Apply --status filter
+      if (filterStatus && sessionStatus !== filterStatus) continue;
+
+      const queue = await readQueue(sessionDir);
+      const marker = isActive ? green("*") : " ";
+      const shortId = dir.substring(repo.length + 1);
 
-    const queue = await readQueue(sessionDir);
-    const marker = isActive ? green("*") : " ";
+      repoEntries.push(`    ${marker} ${cyan(shortId)}  ${info} | ${queue.tasks.length} queued`);
+    }
 
-    console.log(`  ${marker} ${cyan(dir)}  ${info} | ${queue.tasks.length} queued`);
+    if (repoEntries.length > 0) {
+      console.log(`  ${isCurrent ? green(repo) : dim(repo)}`);
+      for (const entry of repoEntries) console.log(entry);
+    }
   }
 
   if (ids.length > 0) {
@@ -484,13 +524,14 @@ async function destroyOne(sessionId: string): Promise<void> {
 
 async function stopAll(): Promise<void> {
   const active = await readActiveSessions();
-  const ids = Object.keys(active);
+  // Scope to current repo
+  const ids = Object.keys(active).filter(isRepoSession);
 
   let allDirs: string[] = [];
-  try { allDirs = await fs.readdir(SESSIONS_DIR); } catch {}
+  try { allDirs = (await fs.readdir(SESSIONS_DIR)).filter(isRepoSession); } catch {}
 
   if (ids.length === 0 && allDirs.length === 0) {
-    console.log(dim("No sessions to stop."));
+    console.log(dim(`No sessions to stop for repo "${REPO_NAME}".`));
     return;
   }
 
@@ -511,33 +552,29 @@ async function stopAll(): Promise<void> {
     }
   }
 
-  // Clear active sessions file
-  await fs.writeFile(ACTIVE_SESSIONS_FILE, "{}");
-  console.log(green("\nAll sessions stopped."));
+  // Remove stopped sessions from active-sessions.json (keep other repos)
+  const remaining = await readActiveSessions();
+  for (const id of ids) delete remaining[id];
+  await fs.writeFile(ACTIVE_SESSIONS_FILE, JSON.stringify(remaining, null, 2));
+  console.log(green(`\nAll ${REPO_NAME} sessions stopped.`));
 }
 
 async function destroyAll(): Promise<void> {
-  // Stop everything first
+  // Stop this repo's sessions first
   await stopAll();
 
-  // Delete all session directories
+  // Delete this repo's session directories only
   try {
-    const dirs = await fs.readdir(SESSIONS_DIR);
+    const dirs = (await fs.readdir(SESSIONS_DIR)).filter(isRepoSession);
     for (const dir of dirs) {
       await fs.rm(path.join(SESSIONS_DIR, dir), { recursive: true, force: true });
     }
   } catch { /* no sessions dir */ }
 
-  // Delete history
-  try { await fs.unlink(HISTORY_FILE); } catch {}
-
-  // Delete active sessions file
-  try { await fs.unlink(ACTIVE_SESSIONS_FILE); } catch {}
-
   // Delete tool history
-  try { await fs.unlink(path.join(GROUNDCREW_DIR, "tool-history.csv")); } catch {}
+  try { await fs.unlink(path.join(GROUNDCREW_HOME, "tool-history.csv")); } catch {}
 
-  console.log(green("All session data and history deleted."));
+  console.log(green(`All ${REPO_NAME} session data deleted.`));
 }
 
 // ── Chat Mode ────────────────────────────────────────────────────────────────
@@ -1241,7 +1278,6 @@ ${bold("groundcrew")} — CLI companion for the Groundcrew Copilot plugin
 ${bold("Usage:")}
   groundcrew chat                              Interactive chat mode (recommended)
   groundcrew chat --session <id>               Chat with a specific session
-  groundcrew init                              Initialize .groundcrew/ in current dir
   groundcrew add <task>                        Add a task to the queue
   groundcrew add --priority <task>             Add an urgent task (processed first)
   groundcrew add --session <id> <task>         Add to a specific session
@@ -1249,12 +1285,14 @@ ${bold("Usage:")}
   groundcrew feedback --session <id> <message> Send feedback to a specific session
   groundcrew queue                             List pending tasks
   groundcrew status                            Show session status and last update
-  groundcrew sessions                          List all sessions
+  groundcrew sessions                          List all sessions (all repos)
+  groundcrew sessions --repo mekari_credit     Filter by repo
+  groundcrew sessions --status active          Filter by status (active/parked/ended)
   groundcrew history                           Show completed tasks
   groundcrew clear                             Clear all pending tasks
-  groundcrew stop                              Stop all active sessions
+  groundcrew stop                              Stop all sessions for current repo
   groundcrew stop --session <id>               Stop a specific session
-  groundcrew destroy                           Delete all sessions, history, and data
+  groundcrew destroy                           Delete all sessions for current repo
   groundcrew destroy --session <id>            Delete a specific session
 
 ${bold("Session targeting:")}
@@ -1288,21 +1326,20 @@ async function main(): Promise<void> {
 
   const rawArgs = process.argv.slice(2);
 
-  // Extract --session flag from anywhere in args
-  const { value: explicitSession, remaining: args } = extractFlag(rawArgs, "--session");
+  // Extract flags from anywhere in args
+  const { value: explicitSession, remaining: args1 } = extractFlag(rawArgs, "--session");
+  const { value: filterRepo, remaining: args2 } = extractFlag(args1, "--repo");
+  const { value: filterStatus, remaining: args } = extractFlag(args2, "--status");
 
   const command = args[0];
 
   // Commands that don't need a session (handle their own resolution)
   switch (command) {
-    case "init":
-      await init();
-      return;
     case "chat":
       await chat(explicitSession);
       return;
     case "sessions":
-      await sessions();
+      await sessions(filterRepo, filterStatus);
       return;
     case "history":
       await history();