@outcomeeng/spx 0.1.6 → 0.1.8

package/dist/cli.js

@@ -1,7 +1,7 @@
 import {
   LEAF_KIND,
   parseWorkItemName
-} from "./chunk-5L7CHFBC.js";
+} from "./chunk-BQLLI7GS.js";
 
 // src/cli.ts
 import { Command } from "commander";
@@ -17,19 +17,19 @@ async function initCommand(options = {}) {
       ["plugin", "marketplace", "list"],
       { cwd }
     );
-    const exists = listOutput.includes("spx-claude");
+    const exists = listOutput.includes("outcomeeng");
     if (!exists) {
       await execa(
         "claude",
-        ["plugin", "marketplace", "add", "simonheimlicher/spx-claude"],
+        ["plugin", "marketplace", "add", "outcomeeng/claude"],
         { cwd }
       );
-      return "\u2713 spx-claude marketplace installed successfully\n\nRun 'claude plugin marketplace list' to view all marketplaces.";
+      return "\u2713 outcomeeng marketplace installed successfully\n\nRun 'claude plugin marketplace list' to view all marketplaces.";
     } else {
-      await execa("claude", ["plugin", "marketplace", "update", "spx-claude"], {
+      await execa("claude", ["plugin", "marketplace", "update", "outcomeeng"], {
         cwd
       });
-      return "\u2713 spx-claude marketplace updated successfully\n\nThe marketplace is now up to date.";
+      return "\u2713 outcomeeng marketplace updated successfully\n\nThe marketplace is now up to date.";
     }
   } catch (error) {
     if (error instanceof Error) {
@@ -643,7 +643,7 @@ Searched for: **/.claude/settings.local.json`;
 
 // src/domains/claude/index.ts
 function registerClaudeCommands(claudeCmd) {
-  claudeCmd.command("init").description("Initialize or update spx-claude marketplace plugin").action(async () => {
+  claudeCmd.command("init").description("Initialize or update outcomeeng marketplace plugin").action(async () => {
     try {
       const output = await initCommand({ cwd: process.cwd() });
       console.log(output);
@@ -704,7 +704,154 @@ var claudeDomain = {
 
 // src/commands/session/archive.ts
 import { mkdir, rename, stat } from "fs/promises";
-import { dirname, join as join2 } from "path";
+import { dirname as dirname2, join as join2 } from "path";
+
+// src/git/root.ts
+import { execa as execa2 } from "execa";
+import { dirname, isAbsolute, join, resolve } from "path";
+
+// src/config/defaults.ts
+var DEFAULT_CONFIG = {
+  specs: {
+    root: "specs",
+    work: {
+      dir: "work",
+      statusDirs: {
+        doing: "doing",
+        backlog: "backlog",
+        done: "archive"
+      }
+    },
+    decisions: "decisions",
+    templates: "templates"
+  },
+  sessions: {
+    dir: ".spx/sessions",
+    statusDirs: {
+      todo: "todo",
+      doing: "doing",
+      archive: "archive"
+    }
+  }
+};
+
+// src/git/root.ts
+var defaultDeps = {
+  execa: async (command, args, options) => {
+    const result = await execa2(command, args, options);
+    return {
+      exitCode: result.exitCode ?? 0,
+      stdout: typeof result.stdout === "string" ? result.stdout : String(result.stdout),
+      stderr: typeof result.stderr === "string" ? result.stderr : String(result.stderr)
+    };
+  }
+};
+var NOT_GIT_REPO_WARNING = "Warning: Not in a git repository. Sessions will be created relative to current directory.";
+function extractStdout(stdout) {
+  if (!stdout) return "";
+  const str = typeof stdout === "string" ? stdout : String(stdout);
+  return str.trim().replace(/\/+$/, "");
+}
+async function detectMainRepoRoot(cwd = process.cwd(), deps = defaultDeps) {
+  try {
+    const toplevelResult = await deps.execa(
+      "git",
+      ["rev-parse", "--show-toplevel"],
+      { cwd, reject: false }
+    );
+    if (toplevelResult.exitCode !== 0 || !toplevelResult.stdout) {
+      return {
+        root: cwd,
+        isGitRepo: false,
+        warning: NOT_GIT_REPO_WARNING
+      };
+    }
+    const toplevel = extractStdout(toplevelResult.stdout);
+    const commonDirResult = await deps.execa(
+      "git",
+      ["rev-parse", "--git-common-dir"],
+      { cwd, reject: false }
+    );
+    if (commonDirResult.exitCode !== 0 || !commonDirResult.stdout) {
+      return {
+        root: toplevel,
+        isGitRepo: true
+      };
+    }
+    const commonDir = extractStdout(commonDirResult.stdout);
+    const absoluteCommonDir = isAbsolute(commonDir) ? commonDir : resolve(toplevel, commonDir);
+    const mainRepoRoot = dirname(absoluteCommonDir);
+    return {
+      root: mainRepoRoot,
+      isGitRepo: true
+    };
+  } catch {
+    return {
+      root: cwd,
+      isGitRepo: false,
+      warning: NOT_GIT_REPO_WARNING
+    };
+  }
+}
+async function resolveSessionConfig(options = {}) {
+  const { sessionsDir, cwd, deps } = options;
+  const { statusDirs: statusDirs2 } = DEFAULT_CONFIG.sessions;
+  if (sessionsDir) {
+    return {
+      config: {
+        todoDir: join(sessionsDir, statusDirs2.todo),
+        doingDir: join(sessionsDir, statusDirs2.doing),
+        archiveDir: join(sessionsDir, statusDirs2.archive)
+      }
+    };
+  }
+  const gitResult = await detectMainRepoRoot(cwd, deps);
+  const baseDir = join(gitResult.root, DEFAULT_CONFIG.sessions.dir);
+  return {
+    config: {
+      todoDir: join(baseDir, statusDirs2.todo),
+      doingDir: join(baseDir, statusDirs2.doing),
+      archiveDir: join(baseDir, statusDirs2.archive)
+    },
+    warning: gitResult.warning
+  };
+}
+
+// src/session/batch.ts
+var BatchError = class extends Error {
+  results;
+  constructor(results) {
+    const failures = results.filter((r) => !r.ok);
+    const successes = results.filter((r) => r.ok);
+    super(
+      `${failures.length} of ${results.length} operations failed. ${successes.length} succeeded.`
+    );
+    this.name = "BatchError";
+    this.results = results;
+  }
+};
+async function processBatch(ids, handler) {
+  const results = [];
+  for (const id of ids) {
+    try {
+      const output2 = await handler(id);
+      results.push({ id, ok: true, message: output2 });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      results.push({ id, ok: false, message });
+    }
+  }
+  const output = results.map((r) => r.ok ? r.message : `Error (${r.id}): ${r.message}`).join("\n\n");
+  const hasFailures = results.some((r) => !r.ok);
+  if (hasFailures) {
+    const err = new BatchError(results);
+    err.message = `${err.message}
+
+${output}`;
+    throw err;
+  }
+  return output;
+}
 
 // src/session/errors.ts
 var SessionError = class extends Error {
@@ -753,33 +900,76 @@ var NoSessionsAvailableError = class extends SessionError {
   }
 };
 
-// src/session/show.ts
-import { join } from "path";
-
-// src/config/defaults.ts
-var DEFAULT_CONFIG = {
-  specs: {
-    root: "specs",
-    work: {
-      dir: "work",
-      statusDirs: {
-        doing: "doing",
-        backlog: "backlog",
-        done: "archive"
-      }
-    },
-    decisions: "decisions",
-    templates: "templates"
-  },
-  sessions: {
-    dir: ".spx/sessions",
-    statusDirs: {
-      todo: "todo",
-      doing: "doing",
-      archive: "archive"
-    }
+// src/commands/session/archive.ts
+var SessionAlreadyArchivedError = class extends Error {
+  /** The session ID that is already archived */
+  sessionId;
+  constructor(sessionId) {
+    super(`Session already archived: ${sessionId}.`);
+    this.name = "SessionAlreadyArchivedError";
+    this.sessionId = sessionId;
   }
 };
+async function resolveArchivePaths(sessionId, config) {
+  const filename = `${sessionId}.md`;
+  const todoPath = join2(config.todoDir, filename);
+  const doingPath = join2(config.doingDir, filename);
+  const archivePath = join2(config.archiveDir, filename);
+  try {
+    const archiveStats = await stat(archivePath);
+    if (archiveStats.isFile()) {
+      throw new SessionAlreadyArchivedError(sessionId);
+    }
+  } catch (error) {
+    if (error instanceof Error && "code" in error && error.code !== "ENOENT") {
+      throw error;
+    }
+    if (error instanceof SessionAlreadyArchivedError) {
+      throw error;
+    }
+  }
+  try {
+    const todoStats = await stat(todoPath);
+    if (todoStats.isFile()) {
+      return { source: todoPath, target: archivePath };
+    }
+  } catch {
+  }
+  try {
+    const doingStats = await stat(doingPath);
+    if (doingStats.isFile()) {
+      return { source: doingPath, target: archivePath };
+    }
+  } catch {
+  }
+  throw new SessionNotFoundError(sessionId);
+}
+async function archiveSingle(sessionId, config) {
+  const { source, target } = await resolveArchivePaths(sessionId, config);
+  await mkdir(dirname2(target), { recursive: true });
+  await rename(source, target);
+  return `Archived session: ${sessionId}
+Archive location: ${target}`;
+}
+async function archiveCommand(options) {
+  const { config } = await resolveSessionConfig({ sessionsDir: options.sessionsDir });
+  return processBatch(options.sessionIds, (id) => archiveSingle(id, config));
+}
+
+// src/commands/session/delete.ts
+import { stat as stat2, unlink } from "fs/promises";
+
+// src/session/delete.ts
+function resolveDeletePath(sessionId, existingPaths) {
+  const matchingPath = existingPaths.find((path8) => path8.includes(sessionId));
+  if (!matchingPath) {
+    throw new SessionNotFoundError(sessionId);
+  }
+  return matchingPath;
+}
+
+// src/session/show.ts
+import { join as join3 } from "path";
 
 // src/session/list.ts
 import { parse as parseYaml } from "yaml";
@@ -819,6 +1009,8 @@ function parseSessionId(id) {
 }
 
 // src/session/types.ts
+var SESSION_STATUSES = ["todo", "doing", "archive"];
+var DEFAULT_LIST_STATUSES = ["doing", "todo"];
 var PRIORITY_ORDER = {
   high: 0,
   medium: 1,
@@ -905,11 +1097,11 @@ function sortSessions(sessions) {
 // src/session/show.ts
 var { dir: sessionsBaseDir, statusDirs } = DEFAULT_CONFIG.sessions;
 var DEFAULT_SESSION_CONFIG = {
-  todoDir: join(sessionsBaseDir, statusDirs.todo),
-  doingDir: join(sessionsBaseDir, statusDirs.doing),
-  archiveDir: join(sessionsBaseDir, statusDirs.archive)
+  todoDir: join3(sessionsBaseDir, statusDirs.todo),
+  doingDir: join3(sessionsBaseDir, statusDirs.doing),
+  archiveDir: join3(sessionsBaseDir, statusDirs.archive)
 };
-var SEARCH_ORDER = ["todo", "doing", "archive"];
+var SEARCH_ORDER = [...SESSION_STATUSES];
 function resolveSessionPaths(id, config = DEFAULT_SESSION_CONFIG) {
   const filename = `${id}.md`;
   return [
@@ -941,76 +1133,6 @@ function formatShowOutput(content, options) {
   return header + separator + content;
 }
 
-// src/commands/session/archive.ts
-var SessionAlreadyArchivedError = class extends Error {
-  /** The session ID that is already archived */
-  sessionId;
-  constructor(sessionId) {
-    super(`Session already archived: ${sessionId}.`);
-    this.name = "SessionAlreadyArchivedError";
-    this.sessionId = sessionId;
-  }
-};
-async function resolveArchivePaths(sessionId, config) {
-  const filename = `${sessionId}.md`;
-  const todoPath = join2(config.todoDir, filename);
-  const doingPath = join2(config.doingDir, filename);
-  const archivePath = join2(config.archiveDir, filename);
-  try {
-    const archiveStats = await stat(archivePath);
-    if (archiveStats.isFile()) {
-      throw new SessionAlreadyArchivedError(sessionId);
-    }
-  } catch (error) {
-    if (error instanceof Error && "code" in error && error.code !== "ENOENT") {
-      throw error;
-    }
-    if (error instanceof SessionAlreadyArchivedError) {
-      throw error;
-    }
-  }
-  try {
-    const todoStats = await stat(todoPath);
-    if (todoStats.isFile()) {
-      return { source: todoPath, target: archivePath };
-    }
-  } catch {
-  }
-  try {
-    const doingStats = await stat(doingPath);
-    if (doingStats.isFile()) {
-      return { source: doingPath, target: archivePath };
-    }
-  } catch {
-  }
-  throw new SessionNotFoundError(sessionId);
-}
-async function archiveCommand(options) {
-  const config = options.sessionsDir ? {
-    todoDir: join2(options.sessionsDir, "todo"),
-    doingDir: join2(options.sessionsDir, "doing"),
-    archiveDir: join2(options.sessionsDir, "archive")
-  } : DEFAULT_SESSION_CONFIG;
-  const { source, target } = await resolveArchivePaths(options.sessionId, config);
-  await mkdir(dirname(target), { recursive: true });
-  await rename(source, target);
-  return `Archived session: ${options.sessionId}
-Archive location: ${target}`;
-}
-
-// src/commands/session/delete.ts
-import { stat as stat2, unlink } from "fs/promises";
-import { join as join3 } from "path";
-
-// src/session/delete.ts
-function resolveDeletePath(sessionId, existingPaths) {
-  const matchingPath = existingPaths.find((path8) => path8.includes(sessionId));
-  if (!matchingPath) {
-    throw new SessionNotFoundError(sessionId);
-  }
-  return matchingPath;
-}
-
 // src/commands/session/delete.ts
 async function findExistingPaths(paths) {
   const existing = [];
@@ -1025,62 +1147,21 @@ async function findExistingPaths(paths) {
   }
   return existing;
 }
-async function deleteCommand(options) {
-  const config = options.sessionsDir ? {
-    todoDir: join3(options.sessionsDir, "todo"),
-    doingDir: join3(options.sessionsDir, "doing"),
-    archiveDir: join3(options.sessionsDir, "archive")
-  } : DEFAULT_SESSION_CONFIG;
-  const paths = resolveSessionPaths(options.sessionId, config);
+async function deleteSingle(sessionId, config) {
+  const paths = resolveSessionPaths(sessionId, config);
   const existingPaths = await findExistingPaths(paths);
-  const pathToDelete = resolveDeletePath(options.sessionId, existingPaths);
+  const pathToDelete = resolveDeletePath(sessionId, existingPaths);
   await unlink(pathToDelete);
-  return `Deleted session: ${options.sessionId}`;
+  return `Deleted session: ${sessionId}`;
+}
+async function deleteCommand(options) {
+  const { config } = await resolveSessionConfig({ sessionsDir: options.sessionsDir });
+  return processBatch(options.sessionIds, (id) => deleteSingle(id, config));
 }
 
 // src/commands/session/handoff.ts
 import { mkdir as mkdir2, writeFile } from "fs/promises";
-import { join as join5, resolve } from "path";
-
-// src/git/root.ts
-import { execa as execa2 } from "execa";
-import { join as join4 } from "path";
-var defaultDeps = {
-  execa: (command, args, options) => execa2(command, args, options)
-};
-var NOT_GIT_REPO_WARNING = "Warning: Not in a git repository. Sessions will be created relative to current directory.";
-async function detectGitRoot(cwd = process.cwd(), deps = defaultDeps) {
-  try {
-    const result = await deps.execa(
-      "git",
-      ["rev-parse", "--show-toplevel"],
-      { cwd, reject: false }
-    );
-    if (result.exitCode === 0 && result.stdout) {
-      const stdout = typeof result.stdout === "string" ? result.stdout : result.stdout.toString();
-      const gitRoot = stdout.trim().replace(/\/+$/, "");
-      return {
-        root: gitRoot,
-        isGitRepo: true
-      };
-    }
-    return {
-      root: cwd,
-      isGitRepo: false,
-      warning: NOT_GIT_REPO_WARNING
-    };
-  } catch {
-    return {
-      root: cwd,
-      isGitRepo: false,
-      warning: NOT_GIT_REPO_WARNING
-    };
-  }
-}
-function buildSessionPathFromRoot(gitRoot, sessionId, config) {
-  const filename = `${sessionId}.md`;
-  return join4(gitRoot, config.todoDir, filename);
-}
+import { join as join4, resolve as resolve2 } from "path";
 
 // src/session/create.ts
 var MIN_CONTENT_LENGTH = 1;
@@ -1101,7 +1182,6 @@ function validateSessionContent(content) {
 }
 
 // src/commands/session/handoff.ts
-var { statusDirs: statusDirs2 } = DEFAULT_CONFIG.sessions;
 var FRONT_MATTER_START = /^---\r?\n/;
 function hasFrontmatter(content) {
   return FRONT_MATTER_START.test(content);
@@ -1126,20 +1206,7 @@ priority: medium
 ${content}`;
 }
 async function handoffCommand(options) {
-  const config = options.sessionsDir ? {
-    todoDir: join5(options.sessionsDir, statusDirs2.todo),
-    doingDir: join5(options.sessionsDir, statusDirs2.doing),
-    archiveDir: join5(options.sessionsDir, statusDirs2.archive)
-  } : DEFAULT_SESSION_CONFIG;
-  let baseDir;
-  let warningMessage;
-  if (options.sessionsDir) {
-    baseDir = options.sessionsDir;
-  } else {
-    const gitResult = await detectGitRoot();
-    baseDir = gitResult.root;
-    warningMessage = gitResult.warning;
-  }
+  const { config, warning } = await resolveSessionConfig({ sessionsDir: options.sessionsDir });
   const sessionId = generateSessionId();
   const fullContent = buildSessionContent(options.content);
   const validation = validateSessionContent(fullContent);
@@ -1147,23 +1214,21 @@ async function handoffCommand(options) {
     throw new SessionInvalidContentError(validation.error ?? "Unknown validation error");
   }
   const filename = `${sessionId}.md`;
-  const sessionPath = options.sessionsDir ? join5(config.todoDir, filename) : buildSessionPathFromRoot(baseDir, sessionId, config);
-  const absolutePath = resolve(sessionPath);
-  const todoDir = options.sessionsDir ? config.todoDir : join5(baseDir, config.todoDir);
-  await mkdir2(todoDir, { recursive: true });
+  const sessionPath = join4(config.todoDir, filename);
+  const absolutePath = resolve2(sessionPath);
+  await mkdir2(config.todoDir, { recursive: true });
   await writeFile(sessionPath, fullContent, "utf-8");
-  let output = `Created handoff session <HANDOFF_ID>${sessionId}</HANDOFF_ID>
-<SESSION_FILE>${absolutePath}</SESSION_FILE>`;
-  if (warningMessage) {
-    process.stderr.write(`${warningMessage}
+  if (warning) {
+    process.stderr.write(`${warning}
 `);
   }
-  return output;
+  return `Created handoff session <HANDOFF_ID>${sessionId}</HANDOFF_ID>
+<SESSION_FILE>${absolutePath}</SESSION_FILE>`;
 }
 
 // src/commands/session/list.ts
 import { readdir, readFile } from "fs/promises";
-import { join as join6 } from "path";
+import { join as join5 } from "path";
 async function loadSessionsFromDir(dir, status) {
   try {
     const files = await readdir(dir);
@@ -1171,7 +1236,7 @@ async function loadSessionsFromDir(dir, status) {
     for (const file of files) {
       if (!file.endsWith(".md")) continue;
       const id = file.replace(".md", "");
-      const filePath = join6(dir, file);
+      const filePath = join5(dir, file);
       const content = await readFile(filePath, "utf-8");
       const metadata = parseSessionMetadata(content);
       sessions.push({
@@ -1189,7 +1254,12 @@ async function loadSessionsFromDir(dir, status) {
     throw error;
   }
 }
-function formatTextOutput(sessions, _status) {
+var STATUS_DIR_KEY = {
+  todo: "todoDir",
+  doing: "doingDir",
+  archive: "archiveDir"
+};
+function formatTextOutput(sessions) {
   if (sessions.length === 0) {
     return `  (no sessions)`;
   }
@@ -1199,47 +1269,38 @@ function formatTextOutput(sessions, _status) {
     return `  ${s.id}${priority}${tags}`;
   }).join("\n");
 }
+function validateStatus(input) {
+  if (SESSION_STATUSES.includes(input)) {
+    return input;
+  }
+  throw new Error(
+    `Invalid status: "${input}". Valid values: ${SESSION_STATUSES.join(", ")}`
+  );
+}
 async function listCommand(options) {
-  const config = options.sessionsDir ? {
-    todoDir: join6(options.sessionsDir, "todo"),
-    doingDir: join6(options.sessionsDir, "doing"),
-    archiveDir: join6(options.sessionsDir, "archive")
-  } : DEFAULT_SESSION_CONFIG;
-  const statuses = options.status ? [options.status] : ["todo", "doing", "archive"];
-  const allSessions = {
-    todo: [],
-    doing: [],
-    archive: []
-  };
+  const { config } = await resolveSessionConfig({ sessionsDir: options.sessionsDir });
+  const statuses = options.status !== void 0 ? [validateStatus(options.status)] : DEFAULT_LIST_STATUSES;
+  const sessionsByStatus = {};
   for (const status of statuses) {
-    const dir = status === "todo" ? config.todoDir : status === "doing" ? config.doingDir : config.archiveDir;
-    const sessions = await loadSessionsFromDir(dir, status);
-    allSessions[status] = sortSessions(sessions);
+    const dirKey = STATUS_DIR_KEY[status];
+    const sessions = await loadSessionsFromDir(config[dirKey], status);
+    sessionsByStatus[status] = sortSessions(sessions);
   }
   if (options.format === "json") {
-    return JSON.stringify(allSessions, null, 2);
+    return JSON.stringify(sessionsByStatus, null, 2);
   }
   const lines = [];
-  if (statuses.includes("doing")) {
-    lines.push("DOING:");
-    lines.push(formatTextOutput(allSessions.doing, "doing"));
-    lines.push("");
-  }
-  if (statuses.includes("todo")) {
-    lines.push("TODO:");
-    lines.push(formatTextOutput(allSessions.todo, "todo"));
+  for (const status of statuses) {
+    lines.push(`${status.toUpperCase()}:`);
+    lines.push(formatTextOutput(sessionsByStatus[status] ?? []));
     lines.push("");
   }
-  if (statuses.includes("archive")) {
-    lines.push("ARCHIVE:");
-    lines.push(formatTextOutput(allSessions.archive, "archive"));
-  }
   return lines.join("\n").trim();
 }
 
 // src/commands/session/pickup.ts
 import { mkdir as mkdir3, readdir as readdir2, readFile as readFile2, rename as rename2 } from "fs/promises";
-import { join as join7 } from "path";
+import { join as join6 } from "path";
 
 // src/session/pickup.ts
 function buildClaimPaths(sessionId, config) {
@@ -1275,6 +1336,8 @@ function selectBestSession(sessions) {
 }
 
 // src/commands/session/pickup.ts
+var PICKUP_SOURCE_STATUS = SESSION_STATUSES[0];
+var PICKUP_TARGET_STATUS = SESSION_STATUSES[1];
 async function loadTodoSessions(config) {
   try {
     const files = await readdir2(config.todoDir);
@@ -1282,12 +1345,12 @@ async function loadTodoSessions(config) {
     for (const file of files) {
       if (!file.endsWith(".md")) continue;
       const id = file.replace(".md", "");
-      const filePath = join7(config.todoDir, file);
+      const filePath = join6(config.todoDir, file);
       const content = await readFile2(filePath, "utf-8");
       const metadata = parseSessionMetadata(content);
       sessions.push({
         id,
-        status: "todo",
+        status: PICKUP_SOURCE_STATUS,
         path: filePath,
         metadata
       });
@@ -1301,11 +1364,7 @@ async function loadTodoSessions(config) {
   }
 }
 async function pickupCommand(options) {
-  const config = options.sessionsDir ? {
-    todoDir: join7(options.sessionsDir, "todo"),
-    doingDir: join7(options.sessionsDir, "doing"),
-    archiveDir: join7(options.sessionsDir, "archive")
-  } : DEFAULT_SESSION_CONFIG;
+  const { config } = await resolveSessionConfig({ sessionsDir: options.sessionsDir });
   let sessionId;
   if (options.auto) {
     const sessions = await loadTodoSessions(config);
@@ -1327,7 +1386,7 @@ async function pickupCommand(options) {
     throw classifyClaimError(error, sessionId);
   }
   const content = await readFile2(paths.target, "utf-8");
-  const output = formatShowOutput(content, { status: "doing" });
+  const output = formatShowOutput(content, { status: PICKUP_TARGET_STATUS });
   return `Claimed session <PICKUP_ID>${sessionId}</PICKUP_ID>
 
 ${output}`;
@@ -1335,7 +1394,8 @@ ${output}`;
 
 // src/commands/session/prune.ts
 import { readdir as readdir3, readFile as readFile3, unlink as unlink2 } from "fs/promises";
-import { join as join8 } from "path";
+import { join as join7 } from "path";
+var PRUNE_STATUS = SESSION_STATUSES[2];
 var DEFAULT_KEEP_COUNT = 5;
 var PruneValidationError = class extends Error {
   constructor(message) {
@@ -1359,12 +1419,12 @@ async function loadArchiveSessions(config) {
     for (const file of files) {
       if (!file.endsWith(".md")) continue;
       const id = file.replace(".md", "");
-      const filePath = join8(config.archiveDir, file);
+      const filePath = join7(config.archiveDir, file);
       const content = await readFile3(filePath, "utf-8");
       const metadata = parseSessionMetadata(content);
       sessions.push({
         id,
-        status: "archive",
+        status: PRUNE_STATUS,
         path: filePath,
         metadata
       });
@@ -1388,11 +1448,7 @@ async function pruneCommand(options) {
   validatePruneOptions(options);
   const keep = options.keep ?? DEFAULT_KEEP_COUNT;
   const dryRun = options.dryRun ?? false;
-  const config = options.sessionsDir ? {
-    todoDir: join8(options.sessionsDir, "todo"),
-    doingDir: join8(options.sessionsDir, "doing"),
-    archiveDir: join8(options.sessionsDir, "archive")
-  } : DEFAULT_SESSION_CONFIG;
+  const { config } = await resolveSessionConfig({ sessionsDir: options.sessionsDir });
   const sessions = await loadArchiveSessions(config);
   const toPrune = selectSessionsToPrune(sessions, keep);
   if (toPrune.length === 0) {
@@ -1421,7 +1477,6 @@ async function pruneCommand(options) {
 
 // src/commands/session/release.ts
 import { readdir as readdir4, rename as rename3 } from "fs/promises";
-import { join as join9 } from "path";
 
 // src/session/release.ts
 function buildReleasePaths(sessionId, config) {
@@ -1458,11 +1513,7 @@ async function loadDoingSessions(config) {
   }
 }
 async function releaseCommand(options) {
-  const config = options.sessionsDir ? {
-    todoDir: join9(options.sessionsDir, "todo"),
-    doingDir: join9(options.sessionsDir, "doing"),
-    archiveDir: join9(options.sessionsDir, "archive")
-  } : DEFAULT_SESSION_CONFIG;
+  const { config } = await resolveSessionConfig({ sessionsDir: options.sessionsDir });
   let sessionId;
   if (options.sessionId) {
     sessionId = options.sessionId;
@@ -1489,7 +1540,6 @@ Session returned to todo directory.`;
 
 // src/commands/session/show.ts
 import { readFile as readFile4, stat as stat3 } from "fs/promises";
-import { join as join10 } from "path";
 async function findExistingPath(paths, _config) {
   for (let i = 0; i < paths.length; i++) {
     const filePath = paths[i];
@@ -1503,20 +1553,19 @@ async function findExistingPath(paths, _config) {
   }
   return null;
 }
-async function showCommand(options) {
-  const config = options.sessionsDir ? {
-    todoDir: join10(options.sessionsDir, "todo"),
-    doingDir: join10(options.sessionsDir, "doing"),
-    archiveDir: join10(options.sessionsDir, "archive")
-  } : DEFAULT_SESSION_CONFIG;
-  const paths = resolveSessionPaths(options.sessionId, config);
+async function showSingle(sessionId, config) {
+  const paths = resolveSessionPaths(sessionId, config);
   const found = await findExistingPath(paths, config);
   if (!found) {
-    throw new SessionNotFoundError(options.sessionId);
+    throw new SessionNotFoundError(sessionId);
   }
   const content = await readFile4(found.path, "utf-8");
   return formatShowOutput(content, { status: found.status });
 }
+async function showCommand(options) {
+  const { config } = await resolveSessionConfig({ sessionsDir: options.sessionsDir });
+  return processBatch(options.sessionIds, (id) => showSingle(id, config));
+}
 
 // src/domains/session/help.ts
 var SESSION_FORMAT_HELP = `
@@ -1535,7 +1584,8 @@ Workflow:
   1. handoff  - Create session (todo)
   2. pickup   - Claim session (todo -> doing)
   3. release  - Return session (doing -> todo)
-  4. delete   - Remove session
+  4. archive  - Move session to archive
+  5. delete   - Remove session permanently
 `;
 var HANDOFF_FRONTMATTER_HELP = `
 Usage:
@@ -1580,17 +1630,17 @@ async function readStdin() {
   if (process.stdin.isTTY) {
     return void 0;
   }
-  return new Promise((resolve2) => {
+  return new Promise((resolve3) => {
     let data = "";
     process.stdin.setEncoding("utf-8");
     process.stdin.on("data", (chunk) => {
       data += chunk;
     });
     process.stdin.on("end", () => {
-      resolve2(data.trim() || void 0);
+      resolve3(data.trim() || void 0);
     });
     process.stdin.on("error", () => {
-      resolve2(void 0);
+      resolve3(void 0);
     });
   });
 }
@@ -1599,7 +1649,7 @@ function handleError(error) {
   process.exit(1);
 }
 function registerSessionCommands(sessionCmd) {
-  sessionCmd.command("list").description("List all sessions").option("--status <status>", "Filter by status (todo|doing|archive)").option("--json", "Output as JSON").option("--sessions-dir <path>", "Custom sessions directory").action(async (options) => {
+  sessionCmd.command("list").description("List active sessions (doing + todo by default)").option("--status <status>", "Filter by status (todo|doing|archive); defaults to doing + todo").option("--json", "Output as JSON").option("--sessions-dir <path>", "Custom sessions directory").action(async (options) => {
     try {
       const output = await listCommand({
         status: options.status,
@@ -1611,10 +1661,22 @@ function registerSessionCommands(sessionCmd) {
       handleError(error);
     }
   });
-  sessionCmd.command("show <id>").description("Show session content").option("--sessions-dir <path>", "Custom sessions directory").action(async (id, options) => {
+  sessionCmd.command("todo").description("List todo sessions").option("--json", "Output as JSON").option("--sessions-dir <path>", "Custom sessions directory").action(async (options) => {
+    try {
+      const output = await listCommand({
+        status: SESSION_STATUSES[0],
+        format: options.json ? "json" : "text",
+        sessionsDir: options.sessionsDir
+      });
+      console.log(output);
+    } catch (error) {
+      handleError(error);
+    }
+  });
+  sessionCmd.command("show <id...>").description("Show session content").option("--sessions-dir <path>", "Custom sessions directory").action(async (ids, options) => {
     try {
       const output = await showCommand({
-        sessionId: id,
+        sessionIds: ids,
         sessionsDir: options.sessionsDir
       });
       console.log(output);
@@ -1661,10 +1723,10 @@ function registerSessionCommands(sessionCmd) {
       handleError(error);
     }
   });
-  sessionCmd.command("delete <id>").description("Delete a session").option("--sessions-dir <path>", "Custom sessions directory").action(async (id, options) => {
+  sessionCmd.command("delete <id...>").description("Delete one or more sessions").option("--sessions-dir <path>", "Custom sessions directory").action(async (ids, options) => {
     try {
       const output = await deleteCommand({
-        sessionId: id,
+        sessionIds: ids,
         sessionsDir: options.sessionsDir
       });
       console.log(output);
@@ -1689,10 +1751,10 @@ function registerSessionCommands(sessionCmd) {
       handleError(error);
     }
   });
-  sessionCmd.command("archive <id>").description("Move a session to the archive directory").option("--sessions-dir <path>", "Custom sessions directory").action(async (id, options) => {
+  sessionCmd.command("archive <id...>").description("Move one or more sessions to the archive directory").option("--sessions-dir <path>", "Custom sessions directory").action(async (ids, options) => {
     try {
       const output = await archiveCommand({
-        sessionId: id,
+        sessionIds: ids,
         sessionsDir: options.sessionsDir
       });
       console.log(output);
@@ -3182,7 +3244,7 @@ var ParseErrorCode;
 
 // src/validation/config/scope.ts
 import { existsSync, readdirSync, readFileSync } from "fs";
-import { join as join11 } from "path";
+import { join as join8 } from "path";
 var TSCONFIG_FILES = {
   full: "tsconfig.json",
   production: "tsconfig.production.json"
@@ -3229,7 +3291,7 @@ function hasTypeScriptFilesRecursive(dirPath, maxDepth = 2, deps = defaultScopeD
     if (hasDirectTsFiles) return true;
     const subdirs = items.filter((item) => item.isDirectory() && !item.name.startsWith("."));
     for (const subdir of subdirs.slice(0, 5)) {
-      if (hasTypeScriptFilesRecursive(join11(dirPath, subdir.name), maxDepth - 1, deps)) {
+      if (hasTypeScriptFilesRecursive(join8(dirPath, subdir.name), maxDepth - 1, deps)) {
         return true;
       }
     }
@@ -3572,7 +3634,7 @@ function buildEslintArgs(context) {
 }
 async function validateESLint(context, runner = defaultEslintProcessRunner) {
   const { scope, validatedFiles, mode } = context;
-  return new Promise((resolve2) => {
+  return new Promise((resolve3) => {
     if (!validatedFiles || validatedFiles.length === 0) {
       if (scope === VALIDATION_SCOPES.PRODUCTION) {
         process.env.ESLINT_PRODUCTION_ONLY = "1";
@@ -3591,13 +3653,13 @@ async function validateESLint(context, runner = defaultEslintProcessRunner) {
     });
     eslintProcess.on("close", (code) => {
       if (code === 0) {
-        resolve2({ success: true });
+        resolve3({ success: true });
       } else {
-        resolve2({ success: false, error: `ESLint exited with code ${code}` });
+        resolve3({ success: false, error: `ESLint exited with code ${code}` });
       }
     });
     eslintProcess.on("error", (error) => {
-      resolve2({ success: false, error: error.message });
+      resolve3({ success: false, error: error.message });
     });
   });
 }
@@ -3644,7 +3706,7 @@ async function validateKnip(typescriptScope, runner = defaultKnipProcessRunner)
     if (analyzeDirectories.length === 0) {
       return { success: true };
     }
-    return new Promise((resolve2) => {
+    return new Promise((resolve3) => {
       const knipProcess = runner.spawn("npx", ["knip"], {
         cwd: process.cwd(),
         stdio: "pipe"
@@ -3659,17 +3721,17 @@ async function validateKnip(typescriptScope, runner = defaultKnipProcessRunner)
       });
       knipProcess.on("close", (code) => {
         if (code === 0) {
-          resolve2({ success: true });
+          resolve3({ success: true });
         } else {
           const errorOutput = knipOutput || knipError || "Unused code detected";
-          resolve2({
+          resolve3({
             success: false,
             error: errorOutput
           });
         }
       });
       knipProcess.on("error", (error) => {
-        resolve2({ success: false, error: error.message });
+        resolve3({ success: false, error: error.message });
       });
     });
   } catch (error) {
@@ -3761,7 +3823,7 @@ import { spawn as spawn3 } from "child_process";
 import { existsSync as existsSync2, mkdirSync, rmSync, writeFileSync } from "fs";
 import { mkdtemp } from "fs/promises";
 import { tmpdir } from "os";
-import { isAbsolute, join as join12 } from "path";
+import { isAbsolute as isAbsolute2, join as join9 } from "path";
 var defaultTypeScriptProcessRunner = { spawn: spawn3 };
 var defaultTypeScriptDeps = {
   mkdtemp,
@@ -3775,19 +3837,19 @@ function buildTypeScriptArgs(context) {
   return scope === VALIDATION_SCOPES.FULL ? ["tsc", "--noEmit"] : ["tsc", "--project", configFile];
 }
 async function createFileSpecificTsconfig(scope, files, deps = defaultTypeScriptDeps) {
-  const tempDir = await deps.mkdtemp(join12(tmpdir(), "validate-ts-"));
-  const configPath = join12(tempDir, "tsconfig.json");
+  const tempDir = await deps.mkdtemp(join9(tmpdir(), "validate-ts-"));
+  const configPath = join9(tempDir, "tsconfig.json");
   const baseConfigFile = TSCONFIG_FILES[scope];
   const projectRoot = process.cwd();
-  const absoluteFiles = files.map((file) => isAbsolute(file) ? file : join12(projectRoot, file));
+  const absoluteFiles = files.map((file) => isAbsolute2(file) ? file : join9(projectRoot, file));
   const tempConfig = {
-    extends: join12(projectRoot, baseConfigFile),
+    extends: join9(projectRoot, baseConfigFile),
     files: absoluteFiles,
     include: [],
     exclude: [],
     compilerOptions: {
       noEmit: true,
-      typeRoots: [join12(projectRoot, "node_modules", "@types")],
+      typeRoots: [join9(projectRoot, "node_modules", "@types")],
       types: ["node"]
     }
   };
@@ -3807,7 +3869,7 @@ async function validateTypeScript(scope, typescriptScope, files, runner = defaul
   if (files && files.length > 0) {
     const { configPath, cleanup } = await createFileSpecificTsconfig(scope, files, deps);
     try {
-      return await new Promise((resolve2) => {
+      return await new Promise((resolve3) => {
         const tscProcess = runner.spawn("npx", ["tsc", "--project", configPath], {
           cwd: process.cwd(),
           stdio: "inherit"
@@ -3815,14 +3877,14 @@ async function validateTypeScript(scope, typescriptScope, files, runner = defaul
         tscProcess.on("close", (code) => {
           cleanup();
           if (code === 0) {
-            resolve2({ success: true, skipped: false });
+            resolve3({ success: true, skipped: false });
           } else {
-            resolve2({ success: false, error: `TypeScript exited with code ${code}` });
+            resolve3({ success: false, error: `TypeScript exited with code ${code}` });
           }
         });
         tscProcess.on("error", (error) => {
           cleanup();
-          resolve2({ success: false, error: error.message });
+          resolve3({ success: false, error: error.message });
         });
       });
     } catch (error) {
@@ -3834,20 +3896,20 @@ async function validateTypeScript(scope, typescriptScope, files, runner = defaul
     tool = "npx";
     tscArgs = buildTypeScriptArgs({ scope, configFile });
   }
-  return new Promise((resolve2) => {
+  return new Promise((resolve3) => {
     const tscProcess = runner.spawn(tool, tscArgs, {
       cwd: process.cwd(),
       stdio: "inherit"
     });
     tscProcess.on("close", (code) => {
       if (code === 0) {
-        resolve2({ success: true, skipped: false });
+        resolve3({ success: true, skipped: false });
       } else {
-        resolve2({ success: false, error: `TypeScript exited with code ${code}` });
+        resolve3({ success: false, error: `TypeScript exited with code ${code}` });
       }
     });
     tscProcess.on("error", (error) => {
-      resolve2({ success: false, error: error.message });
+      resolve3({ success: false, error: error.message });
     });
   });
 }