@outcomeeng/spx 0.1.0

package/dist/cli.js

@@ -0,0 +1,4023 @@
+import {
+  LEAF_KIND,
+  parseWorkItemName
+} from "./chunk-5L7CHFBC.js";
+
+// src/cli.ts
+import { Command } from "commander";
+
+// src/commands/claude/init.ts
+import { execa } from "execa";
+async function initCommand(options = {}) {
+  const cwd = options.cwd || process.cwd();
+  try {
+    const { stdout: listOutput } = await execa(
+      "claude",
+      ["plugin", "marketplace", "list"],
+      { cwd }
+    );
+    const exists = listOutput.includes("spx-claude");
+    if (!exists) {
+      await execa(
+        "claude",
+        ["plugin", "marketplace", "add", "simonheimlicher/spx-claude"],
+        { cwd }
+      );
+      return "\u2713 spx-claude marketplace installed successfully\n\nRun 'claude plugin marketplace list' to view all marketplaces.";
+    } else {
+      await execa("claude", ["plugin", "marketplace", "update", "spx-claude"], {
+        cwd
+      });
+      return "\u2713 spx-claude marketplace updated successfully\n\nThe marketplace is now up to date.";
+    }
+  } catch (error) {
+    if (error instanceof Error) {
+      if (error.message.includes("ENOENT") || error.message.includes("command not found")) {
+        throw new Error(
+          "Claude CLI not found. Please install Claude Code first.\n\nVisit: https://docs.anthropic.com/claude-code"
+        );
+      }
+      throw new Error(`Failed to initialize marketplace: ${error.message}`);
+    }
+    throw error;
+  }
+}
+
+// src/commands/claude/settings/consolidate.ts
+import os2 from "os";
+import path4 from "path";
+
+// src/lib/claude/permissions/discovery.ts
+import fs from "fs/promises";
+import path from "path";
+async function findSettingsFiles(root, visited = /* @__PURE__ */ new Set()) {
+  const normalizedRoot = path.resolve(root.replace(/^~/, process.env.HOME || "~"));
+  if (visited.has(normalizedRoot)) {
+    return [];
+  }
+  visited.add(normalizedRoot);
+  try {
+    const stats = await fs.stat(normalizedRoot);
+    if (!stats.isDirectory()) {
+      throw new Error(`Path is not a directory: ${normalizedRoot}`);
+    }
+    const entries = await fs.readdir(normalizedRoot, { withFileTypes: true });
+    const results = [];
+    for (const entry of entries) {
+      const fullPath = path.join(normalizedRoot, entry.name);
+      if (entry.isDirectory() && entry.name === ".claude") {
+        const settingsPath = path.join(fullPath, "settings.local.json");
+        if (await isValidSettingsFile(settingsPath)) {
+          results.push(settingsPath);
+        }
+      }
+      if (entry.isDirectory() && entry.name !== ".claude") {
+        const subFiles = await findSettingsFiles(fullPath, visited);
+        results.push(...subFiles);
+      }
+    }
+    return results;
+  } catch (error) {
+    if (error instanceof Error) {
+      if (error.message.includes("ENOENT")) {
+        throw new Error(`Directory not found: ${normalizedRoot}`);
+      }
+      if (error.message.includes("EACCES")) {
+        throw new Error(`Permission denied: ${normalizedRoot}`);
+      }
+      throw new Error(
+        `Failed to search directory "${normalizedRoot}": ${error.message}`
+      );
+    }
+    throw error;
+  }
+}
+async function isValidSettingsFile(filePath) {
+  try {
+    await fs.access(filePath, fs.constants.R_OK);
+    const stats = await fs.stat(filePath);
+    if (!stats.isFile()) {
+      return false;
+    }
+    return path.extname(filePath) === ".json";
+  } catch {
+    return false;
+  }
+}
+
+// src/lib/claude/permissions/parser.ts
+import fs2 from "fs/promises";
+async function parseSettingsFile(filePath) {
+  try {
+    const content = await fs2.readFile(filePath, "utf-8");
+    const parsed = JSON.parse(content);
+    if (typeof parsed !== "object" || parsed === null) {
+      return null;
+    }
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+function parsePermission(raw, category) {
+  const match = raw.match(/^([^(]+)\((.+)\)$/);
+  if (!match) {
+    throw new Error(`Malformed permission string: "${raw}"`);
+  }
+  const [, type, scope] = match;
+  return {
+    raw,
+    type: type.trim(),
+    scope: scope.trim(),
+    category
+  };
+}
+async function parseAllSettings(filePaths) {
+  const results = [];
+  for (const filePath of filePaths) {
+    const settings = await parseSettingsFile(filePath);
+    if (settings?.permissions) {
+      results.push(settings.permissions);
+    }
+  }
+  return results;
+}
+
+// src/scanner/walk.ts
+import fs3 from "fs/promises";
+import path2 from "path";
+async function walkDirectory(root, visited = /* @__PURE__ */ new Set()) {
+  const normalizedRoot = path2.resolve(root);
+  if (visited.has(normalizedRoot)) {
+    return [];
+  }
+  visited.add(normalizedRoot);
+  try {
+    const entries = await fs3.readdir(normalizedRoot, { withFileTypes: true });
+    const results = [];
+    for (const entry of entries) {
+      const fullPath = path2.join(normalizedRoot, entry.name);
+      if (entry.isDirectory()) {
+        results.push({
+          name: entry.name,
+          path: fullPath,
+          isDirectory: true
+        });
+        const subEntries = await walkDirectory(fullPath, visited);
+        results.push(...subEntries);
+      }
+    }
+    return results;
+  } catch (error) {
+    if (error instanceof Error) {
+      throw new Error(
+        `Failed to walk directory "${normalizedRoot}": ${error.message}`
+      );
+    }
+    throw error;
+  }
+}
+function filterWorkItemDirectories(entries) {
+  return entries.filter((entry) => {
+    try {
+      parseWorkItemName(entry.name);
+      return true;
+    } catch {
+      return false;
+    }
+  });
+}
+function buildWorkItemList(entries) {
+  return entries.map((entry) => ({
+    ...parseWorkItemName(entry.name),
+    path: entry.path
+  }));
+}
+function normalizePath(filepath) {
+  return filepath.replace(/\\/g, "/");
+}
+
+// src/lib/claude/permissions/subsumption.ts
+function parseScopePattern(scope) {
+  if (scope.includes("file_path:") || scope.includes("directory_path:") || scope.includes("path:")) {
+    const colonIndex = scope.indexOf(":");
+    const pattern = colonIndex >= 0 ? scope.substring(colonIndex + 1) : scope;
+    return { type: "path", pattern };
+  }
+  return { type: "command", pattern: scope };
+}
+function subsumes(broader, narrower) {
+  if (broader.type !== narrower.type) {
+    return false;
+  }
+  if (broader.scope === narrower.scope) {
+    return false;
+  }
+  const broaderScope = parseScopePattern(broader.scope);
+  const narrowerScope = parseScopePattern(narrower.scope);
+  if (broaderScope.type === "command" && narrowerScope.type === "command") {
+    const broaderBase = broaderScope.pattern.replace(/:?\*+$/, "");
+    const narrowerFull = narrowerScope.pattern.replace(/:?\*+$/, "");
+    if (narrowerFull.startsWith(broaderBase)) {
+      return narrowerFull.length > broaderBase.length;
+    }
+  }
+  if (broaderScope.type === "path" && narrowerScope.type === "path") {
+    const broaderPath = normalizePath(broaderScope.pattern.replace(/\/?\*+$/, ""));
+    const narrowerPath = normalizePath(narrowerScope.pattern.replace(/\/?\*+$/, ""));
+    return narrowerPath.startsWith(broaderPath + "/");
+  }
+  return false;
+}
+function detectSubsumptions(permissions) {
+  const results = [];
+  const processedBroader = /* @__PURE__ */ new Set();
+  for (let i = 0; i < permissions.length; i++) {
+    const broader = permissions[i];
+    if (processedBroader.has(broader.raw)) {
+      continue;
+    }
+    const narrowerPerms = [];
+    for (let j = 0; j < permissions.length; j++) {
+      if (i === j) continue;
+      const narrower = permissions[j];
+      if (subsumes(broader, narrower)) {
+        narrowerPerms.push(narrower);
+      }
+    }
+    if (narrowerPerms.length > 0) {
+      results.push({
+        broader,
+        narrower: narrowerPerms
+      });
+      processedBroader.add(broader.raw);
+    }
+  }
+  return results;
+}
+function removeSubsumed(permissionStrings, category) {
+  const permissions = permissionStrings.map((raw) => {
+    try {
+      return parsePermission(raw, category);
+    } catch {
+      return null;
+    }
+  }).filter((p) => p !== null);
+  const subsumptions = detectSubsumptions(permissions);
+  const toRemove = /* @__PURE__ */ new Set();
+  for (const result of subsumptions) {
+    for (const narrower of result.narrower) {
+      toRemove.add(narrower.raw);
+    }
+  }
+  return permissionStrings.filter((perm) => !toRemove.has(perm));
+}
+
+// src/lib/claude/permissions/merger.ts
+function mergePermissions(global, local) {
+  const originalGlobal = {
+    allow: new Set(global.allow || []),
+    deny: new Set(global.deny || []),
+    ask: new Set(global.ask || [])
+  };
+  const combined = {
+    allow: [...global.allow || []],
+    deny: [...global.deny || []],
+    ask: [...global.ask || []]
+  };
+  let filesProcessed = 0;
+  let filesSkipped = 0;
+  for (const localPerms of local) {
+    let hasPerms = false;
+    if (localPerms.allow && localPerms.allow.length > 0) {
+      combined.allow?.push(...localPerms.allow);
+      hasPerms = true;
+    }
+    if (localPerms.deny && localPerms.deny.length > 0) {
+      combined.deny?.push(...localPerms.deny);
+      hasPerms = true;
+    }
+    if (localPerms.ask && localPerms.ask.length > 0) {
+      combined.ask?.push(...localPerms.ask);
+      hasPerms = true;
+    }
+    if (hasPerms) {
+      filesProcessed++;
+    } else {
+      filesSkipped++;
+    }
+  }
+  const allSubsumed = [];
+  const afterSubsumption = {};
+  if (combined.allow && combined.allow.length > 0) {
+    const before = new Set(combined.allow);
+    combined.allow = removeSubsumed(combined.allow, "allow");
+    const after = new Set(combined.allow);
+    for (const perm of before) {
+      if (!after.has(perm)) {
+        allSubsumed.push(perm);
+      }
+    }
+  }
+  if (combined.deny && combined.deny.length > 0) {
+    const before = new Set(combined.deny);
+    combined.deny = removeSubsumed(combined.deny, "deny");
+    const after = new Set(combined.deny);
+    for (const perm of before) {
+      if (!after.has(perm)) {
+        allSubsumed.push(perm);
+      }
+    }
+  }
+  if (combined.ask && combined.ask.length > 0) {
+    const before = new Set(combined.ask);
+    combined.ask = removeSubsumed(combined.ask, "ask");
+    const after = new Set(combined.ask);
+    for (const perm of before) {
+      if (!after.has(perm)) {
+        allSubsumed.push(perm);
+      }
+    }
+  }
+  afterSubsumption.allow = combined.allow;
+  afterSubsumption.deny = combined.deny;
+  afterSubsumption.ask = combined.ask;
+  const {
+    resolved,
+    conflictCount,
+    subsumed: conflictSubsumed
+  } = resolveConflicts(afterSubsumption);
+  const subsumed = [...allSubsumed, ...conflictSubsumed];
+  const merged = {};
+  if (resolved.allow && resolved.allow.length > 0) {
+    merged.allow = Array.from(new Set(resolved.allow)).sort();
+  }
+  if (resolved.deny && resolved.deny.length > 0) {
+    merged.deny = Array.from(new Set(resolved.deny)).sort();
+  }
+  if (resolved.ask && resolved.ask.length > 0) {
+    merged.ask = Array.from(new Set(resolved.ask)).sort();
+  }
+  const added = {
+    allow: [],
+    deny: [],
+    ask: []
+  };
+  for (const perm of merged.allow || []) {
+    if (!originalGlobal.allow.has(perm)) {
+      added.allow.push(perm);
+    }
+  }
+  for (const perm of merged.deny || []) {
+    if (!originalGlobal.deny.has(perm)) {
+      added.deny.push(perm);
+    }
+  }
+  for (const perm of merged.ask || []) {
+    if (!originalGlobal.ask.has(perm)) {
+      added.ask.push(perm);
+    }
+  }
+  const result = {
+    filesScanned: local.length,
+    filesProcessed,
+    filesSkipped,
+    added,
+    subsumed,
+    conflictsResolved: conflictCount
+  };
+  return { merged, result };
+}
+function resolveConflicts(permissions) {
+  const allow = permissions.allow || [];
+  const deny = permissions.deny || [];
+  const ask = permissions.ask || [];
+  const denySet = new Set(deny);
+  const subsumed = [];
+  let conflictCount = 0;
+  const allowToRemove = /* @__PURE__ */ new Set();
+  for (const allowPerm of allow) {
+    if (denySet.has(allowPerm)) {
+      allowToRemove.add(allowPerm);
+      conflictCount++;
+      continue;
+    }
+    for (const denyPerm of deny) {
+      try {
+        const allowParsed = parsePermission(allowPerm, "allow");
+        const denyParsed = parsePermission(denyPerm, "deny");
+        if (subsumes(denyParsed, allowParsed)) {
+          allowToRemove.add(allowPerm);
+          subsumed.push(allowPerm);
+          conflictCount++;
+          break;
+        }
+      } catch {
+        continue;
+      }
+    }
+  }
+  const resolved = {
+    allow: allow.filter((p) => !allowToRemove.has(p)),
+    deny,
+    ask
+  };
+  return { resolved, conflictCount, subsumed };
+}
+
+// src/lib/claude/settings/backup.ts
+import fs4 from "fs/promises";
+async function createBackup(settingsPath) {
+  try {
+    await fs4.access(settingsPath, fs4.constants.R_OK);
+    const now = /* @__PURE__ */ new Date();
+    const timestamp = [
+      now.getFullYear(),
+      String(now.getMonth() + 1).padStart(2, "0"),
+      String(now.getDate()).padStart(2, "0")
+    ].join("-") + "-" + [
+      String(now.getHours()).padStart(2, "0"),
+      String(now.getMinutes()).padStart(2, "0"),
+      String(now.getSeconds()).padStart(2, "0")
+    ].join("");
+    const backupPath = `${settingsPath}.backup.${timestamp}`;
+    await fs4.copyFile(settingsPath, backupPath);
+    return backupPath;
+  } catch (error) {
+    if (error instanceof Error) {
+      if (error.message.includes("ENOENT")) {
+        throw new Error(`Settings file not found: ${settingsPath}`);
+      }
+      if (error.message.includes("EACCES")) {
+        throw new Error(`Permission denied: ${settingsPath}`);
+      }
+      throw new Error(`Failed to create backup: ${error.message}`);
+    }
+    throw error;
+  }
+}
+
+// src/lib/claude/settings/reporter.ts
+function formatReport(result, previewOnly, globalSettingsPath, outputFile) {
+  const lines = [];
+  lines.push("Scanning for Claude Code settings files...");
+  lines.push("");
+  lines.push(`Found ${result.filesScanned} settings files`);
+  lines.push(`  Processed: ${result.filesProcessed}`);
+  if (result.filesSkipped > 0) {
+    lines.push(`  Skipped: ${result.filesSkipped} (no permissions)`);
+  }
+  lines.push("");
+  const totalAdded = result.added.allow.length + result.added.deny.length + result.added.ask.length;
+  if (totalAdded > 0) {
+    lines.push(`Permissions to add: ${totalAdded}`);
+    if (result.added.allow.length > 0) {
+      lines.push("");
+      lines.push("  allow:");
+      for (const perm of result.added.allow) {
+        lines.push(`    + ${perm}`);
+      }
+    }
+    if (result.added.deny.length > 0) {
+      lines.push("");
+      lines.push("  deny:");
+      for (const perm of result.added.deny) {
+        lines.push(`    + ${perm}`);
+      }
+    }
+    if (result.added.ask.length > 0) {
+      lines.push("");
+      lines.push("  ask:");
+      for (const perm of result.added.ask) {
+        lines.push(`    + ${perm}`);
+      }
+    }
+  } else {
+    lines.push("No new permissions to add (all permissions already in global settings)");
+  }
+  lines.push("");
+  if (result.subsumed.length > 0) {
+    lines.push(`Subsumed permissions removed: ${result.subsumed.length}`);
+    lines.push("  (narrower permissions replaced by broader ones)");
+    for (const perm of result.subsumed) {
+      lines.push(`    - ${perm}`);
+    }
+    lines.push("");
+  }
+  if (result.conflictsResolved > 0) {
+    lines.push(`Conflicts resolved: ${result.conflictsResolved}`);
+    lines.push("  (permissions moved from allow to deny)");
+    lines.push("");
+  }
+  if (result.backupPath) {
+    lines.push(`Backup created: ${result.backupPath}`);
+    lines.push("");
+  }
+  lines.push("Summary:");
+  lines.push(`  Files scanned: ${result.filesScanned}`);
+  lines.push(
+    `  Permissions added: ${result.added.allow.length} allow, ${result.added.deny.length} deny, ${result.added.ask.length} ask`
+  );
+  if (result.subsumed.length > 0) {
+    lines.push(`  Subsumed removed: ${result.subsumed.length}`);
+  }
+  if (result.conflictsResolved > 0) {
+    lines.push(`  Conflicts resolved: ${result.conflictsResolved}`);
+  }
+  lines.push("");
+  if (previewOnly) {
+    lines.push("\u2139\uFE0F  Preview mode: No changes written");
+    lines.push("");
+    lines.push("To apply changes:");
+    lines.push(`  \u2022 Modify global settings: spx claude settings consolidate --write`);
+    lines.push(`  \u2022 Write to file: spx claude settings consolidate --output-file /path/to/file`);
+  } else if (outputFile) {
+    lines.push(`\u2713 Settings written to: ${result.outputPath || outputFile}`);
+    lines.push("");
+    lines.push("To apply to your global settings:");
+    lines.push(`  \u2022 Review the file, then copy to: ${globalSettingsPath || "~/.claude/settings.json"}`);
+    lines.push(`  \u2022 Or run: spx claude settings consolidate --write`);
+  } else {
+    lines.push(`\u2713 Global settings updated: ${globalSettingsPath || "~/.claude/settings.json"}`);
+  }
+  return lines.join("\n");
+}
+
+// src/lib/claude/settings/writer.ts
+import fs5 from "fs/promises";
+import os from "os";
+import path3 from "path";
+var realFs = {
+  writeFile: (path8, content) => fs5.writeFile(path8, content, "utf-8"),
+  rename: fs5.rename,
+  unlink: fs5.unlink,
+  mkdir: async (path8, options) => {
+    await fs5.mkdir(path8, options);
+  }
+};
+async function writeSettings(filePath, settings, deps = { fs: realFs }) {
+  const dir = path3.dirname(filePath);
+  await deps.fs.mkdir(dir, { recursive: true });
+  const tempPath = path3.join(
+    os.tmpdir(),
+    `settings-${Date.now()}-${Math.random().toString(36).substring(7)}.json`
+  );
+  try {
+    const content = JSON.stringify(settings, null, 2) + "\n";
+    await deps.fs.writeFile(tempPath, content);
+    await deps.fs.rename(tempPath, filePath);
+  } catch (error) {
+    try {
+      await deps.fs.unlink(tempPath);
+    } catch {
+    }
+    if (error instanceof Error) {
+      throw new Error(`Failed to write settings: ${error.message}`);
+    }
+    throw error;
+  }
+}
+
+// src/commands/claude/settings/consolidate.ts
+async function consolidateCommand(options = {}) {
+  const root = options.root ? path4.resolve(options.root.replace(/^~/, os2.homedir())) : path4.join(os2.homedir(), "Code");
+  const globalSettingsPath = options.globalSettings || path4.join(os2.homedir(), ".claude", "settings.json");
+  const shouldWrite = options.write || false;
+  const outputFile = options.outputFile;
+  const previewOnly = !shouldWrite && !outputFile;
+  const settingsFiles = await findSettingsFiles(root);
+  if (settingsFiles.length === 0) {
+    return `No settings files found in ${root}
+
+Searched for: **/.claude/settings.local.json`;
+  }
+  const localPermissions = await parseAllSettings(settingsFiles);
+  let globalSettings = await parseSettingsFile(globalSettingsPath);
+  if (!globalSettings) {
+    globalSettings = {
+      permissions: {
+        allow: [],
+        deny: [],
+        ask: []
+      }
+    };
+  }
+  if (!globalSettings.permissions) {
+    globalSettings.permissions = {
+      allow: [],
+      deny: [],
+      ask: []
+    };
+  }
+  const { merged, result } = mergePermissions(
+    globalSettings.permissions,
+    localPermissions
+  );
+  if (shouldWrite) {
+    try {
+      result.backupPath = await createBackup(globalSettingsPath);
+    } catch (error) {
+      if (error instanceof Error && !error.message.includes("not found")) {
+        throw error;
+      }
+    }
+  }
+  if (shouldWrite) {
+    const updatedSettings = {
+      ...globalSettings,
+      permissions: merged
+    };
+    await writeSettings(globalSettingsPath, updatedSettings);
+  } else if (outputFile) {
+    const updatedSettings = {
+      ...globalSettings,
+      permissions: merged
+    };
+    const resolvedOutputPath = path4.resolve(outputFile.replace(/^~/, os2.homedir()));
+    await writeSettings(resolvedOutputPath, updatedSettings);
+    result.outputPath = resolvedOutputPath;
+  }
+  return formatReport(result, previewOnly, globalSettingsPath, outputFile);
+}
+
+// src/domains/claude/index.ts
+function registerClaudeCommands(claudeCmd) {
+  claudeCmd.command("init").description("Initialize or update spx-claude marketplace plugin").action(async () => {
+    try {
+      const output = await initCommand({ cwd: process.cwd() });
+      console.log(output);
+    } catch (error) {
+      console.error(
+        "Error:",
+        error instanceof Error ? error.message : String(error)
+      );
+      process.exit(1);
+    }
+  });
+  const settingsCmd = claudeCmd.command("settings").description("Manage Claude Code settings");
+  settingsCmd.command("consolidate").description(
+    "Consolidate permissions from project-specific settings into global settings"
+  ).option("--write", "Write changes to global settings file (default: preview only)").option(
+    "--output-file <path>",
+    "Write merged settings to specified file instead of global settings"
+  ).option(
+    "--root <path>",
+    "Root directory to scan for settings files (default: ~/Code)"
+  ).option(
+    "--global-settings <path>",
+    "Path to global settings file (default: ~/.claude/settings.json)"
+  ).action(
+    async (options) => {
+      try {
+        if (options.write && options.outputFile) {
+          console.error(
+            "Error: --write and --output-file are mutually exclusive\nUse --write to modify global settings, or --output-file to write to a different location"
+          );
+          process.exit(1);
+        }
+        const output = await consolidateCommand({
+          write: options.write,
+          outputFile: options.outputFile,
+          root: options.root,
+          globalSettings: options.globalSettings
+        });
+        console.log(output);
+      } catch (error) {
+        console.error(
+          "Error:",
+          error instanceof Error ? error.message : String(error)
+        );
+        process.exit(1);
+      }
+    }
+  );
+}
+var claudeDomain = {
+  name: "claude",
+  description: "Manage Claude Code settings and plugins",
+  register: (program2) => {
+    const claudeCmd = program2.command("claude").description("Manage Claude Code settings and plugins");
+    registerClaudeCommands(claudeCmd);
+  }
+};
+
+// src/commands/session/archive.ts
+import { mkdir, rename, stat } from "fs/promises";
+import { dirname, join as join2 } from "path";
+
+// src/session/errors.ts
+var SessionError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "SessionError";
+  }
+};
+var SessionNotFoundError = class extends SessionError {
+  /** The session ID that was not found */
+  sessionId;
+  constructor(sessionId) {
+    super(`Session not found: ${sessionId}. Check the session ID and try again.`);
+    this.name = "SessionNotFoundError";
+    this.sessionId = sessionId;
+  }
+};
+var SessionNotAvailableError = class extends SessionError {
+  /** The session ID that is not available */
+  sessionId;
+  constructor(sessionId) {
+    super(`Session not available: ${sessionId}. It may have been claimed by another agent.`);
+    this.name = "SessionNotAvailableError";
+    this.sessionId = sessionId;
+  }
+};
+var SessionInvalidContentError = class extends SessionError {
+  constructor(reason) {
+    super(`Invalid session content: ${reason}`);
+    this.name = "SessionInvalidContentError";
+  }
+};
+var SessionNotClaimedError = class extends SessionError {
+  /** The session ID that is not claimed */
+  sessionId;
+  constructor(sessionId) {
+    super(`Session not claimed: ${sessionId}. The session is not in the doing directory.`);
+    this.name = "SessionNotClaimedError";
+    this.sessionId = sessionId;
+  }
+};
+var NoSessionsAvailableError = class extends SessionError {
+  constructor() {
+    super("No sessions available. The todo directory is empty.");
+    this.name = "NoSessionsAvailableError";
+  }
+};
+
+// 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/session/list.ts
+import { parse as parseYaml } from "yaml";
+
+// src/session/timestamp.ts
+var SESSION_ID_PATTERN = /^(\d{4})-(\d{2})-(\d{2})_(\d{2})-(\d{2})-(\d{2})$/;
+var SESSION_ID_SEPARATOR = "_";
+function generateSessionId(options = {}) {
+  const now = options.now ?? (() => /* @__PURE__ */ new Date());
+  const date = now();
+  const year = date.getFullYear();
+  const month = String(date.getMonth() + 1).padStart(2, "0");
+  const day = String(date.getDate()).padStart(2, "0");
+  const hours = String(date.getHours()).padStart(2, "0");
+  const minutes = String(date.getMinutes()).padStart(2, "0");
+  const seconds = String(date.getSeconds()).padStart(2, "0");
+  return `${year}-${month}-${day}${SESSION_ID_SEPARATOR}${hours}-${minutes}-${seconds}`;
+}
+function parseSessionId(id) {
+  const match = SESSION_ID_PATTERN.exec(id);
+  if (!match) {
+    return null;
+  }
+  const [, yearStr, monthStr, dayStr, hoursStr, minutesStr, secondsStr] = match;
+  const year = parseInt(yearStr, 10);
+  const month = parseInt(monthStr, 10) - 1;
+  const day = parseInt(dayStr, 10);
+  const hours = parseInt(hoursStr, 10);
+  const minutes = parseInt(minutesStr, 10);
+  const seconds = parseInt(secondsStr, 10);
+  if (month < 0 || month > 11) return null;
+  if (day < 1 || day > 31) return null;
+  if (hours < 0 || hours > 23) return null;
+  if (minutes < 0 || minutes > 59) return null;
+  if (seconds < 0 || seconds > 59) return null;
+  return new Date(year, month, day, hours, minutes, seconds);
+}
+
+// src/session/types.ts
+var PRIORITY_ORDER = {
+  high: 0,
+  medium: 1,
+  low: 2
+};
+var DEFAULT_PRIORITY = "medium";
+
+// src/session/list.ts
+var FRONT_MATTER_PATTERN = /^---\r?\n([\s\S]*?)\r?\n(?:---|\.\.\.)\r?\n?/;
+function isValidPriority(value) {
+  return value === "high" || value === "medium" || value === "low";
+}
+function parseSessionMetadata(content) {
+  const match = FRONT_MATTER_PATTERN.exec(content);
+  if (!match) {
+    return {
+      priority: DEFAULT_PRIORITY,
+      tags: []
+    };
+  }
+  try {
+    const parsed = parseYaml(match[1]);
+    if (!parsed || typeof parsed !== "object") {
+      return {
+        priority: DEFAULT_PRIORITY,
+        tags: []
+      };
+    }
+    const priority = isValidPriority(parsed.priority) ? parsed.priority : DEFAULT_PRIORITY;
+    let tags = [];
+    if (Array.isArray(parsed.tags)) {
+      tags = parsed.tags.filter((t) => typeof t === "string");
+    }
+    const metadata = {
+      priority,
+      tags
+    };
+    if (typeof parsed.id === "string") {
+      metadata.id = parsed.id;
+    }
+    if (typeof parsed.branch === "string") {
+      metadata.branch = parsed.branch;
+    }
+    if (typeof parsed.created_at === "string") {
+      metadata.createdAt = parsed.created_at;
+    }
+    if (typeof parsed.working_directory === "string") {
+      metadata.workingDirectory = parsed.working_directory;
+    }
+    if (Array.isArray(parsed.specs)) {
+      metadata.specs = parsed.specs.filter(
+        (s) => typeof s === "string"
+      );
+    }
+    if (Array.isArray(parsed.files)) {
+      metadata.files = parsed.files.filter(
+        (f) => typeof f === "string"
+      );
+    }
+    return metadata;
+  } catch {
+    return {
+      priority: DEFAULT_PRIORITY,
+      tags: []
+    };
+  }
+}
+function sortSessions(sessions) {
+  return [...sessions].sort((a, b) => {
+    const priorityA = PRIORITY_ORDER[a.metadata.priority];
+    const priorityB = PRIORITY_ORDER[b.metadata.priority];
+    if (priorityA !== priorityB) {
+      return priorityA - priorityB;
+    }
+    const dateA = parseSessionId(a.id);
+    const dateB = parseSessionId(b.id);
+    if (!dateA && !dateB) return 0;
+    if (!dateA) return 1;
+    if (!dateB) return -1;
+    return dateB.getTime() - dateA.getTime();
+  });
+}
+
+// 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)
+};
+var SEARCH_ORDER = ["todo", "doing", "archive"];
+function resolveSessionPaths(id, config = DEFAULT_SESSION_CONFIG) {
+  const filename = `${id}.md`;
+  return [
+    `${config.todoDir}/${filename}`,
+    `${config.doingDir}/${filename}`,
+    `${config.archiveDir}/${filename}`
+  ];
+}
+function formatShowOutput(content, options) {
+  const metadata = parseSessionMetadata(content);
+  const headerLines = [
+    `Status: ${options.status}`,
+    `Priority: ${metadata.priority}`
+  ];
+  if (metadata.id) {
+    headerLines.unshift(`ID: ${metadata.id}`);
+  }
+  if (metadata.branch) {
+    headerLines.push(`Branch: ${metadata.branch}`);
+  }
+  if (metadata.tags.length > 0) {
+    headerLines.push(`Tags: ${metadata.tags.join(", ")}`);
+  }
+  if (metadata.createdAt) {
+    headerLines.push(`Created: ${metadata.createdAt}`);
+  }
+  const header = headerLines.join("\n");
+  const separator = "\n" + "\u2500".repeat(40) + "\n\n";
+  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 = [];
+  for (const path8 of paths) {
+    try {
+      const stats = await stat2(path8);
+      if (stats.isFile()) {
+        existing.push(path8);
+      }
+    } catch {
+    }
+  }
+  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);
+  const existingPaths = await findExistingPaths(paths);
+  const pathToDelete = resolveDeletePath(options.sessionId, existingPaths);
+  await unlink(pathToDelete);
+  return `Deleted session: ${options.sessionId}`;
+}
+
+// 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);
+}
+
+// src/session/create.ts
+var MIN_CONTENT_LENGTH = 1;
+function validateSessionContent(content) {
+  if (!content || content.trim().length < MIN_CONTENT_LENGTH) {
+    return {
+      valid: false,
+      error: "Session content cannot be empty"
+    };
+  }
+  if (content.trim().length === 0) {
+    return {
+      valid: false,
+      error: "Session content cannot be only whitespace"
+    };
+  }
+  return { valid: true };
+}
+
+// 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);
+}
+function buildSessionContent(content) {
+  if (!content || content.trim().length === 0) {
+    return `---
+priority: medium
+---
+
+# New Session
+
+Describe your task here.`;
+  }
+  if (hasFrontmatter(content)) {
+    return content;
+  }
+  return `---
+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 sessionId = generateSessionId();
+  const fullContent = buildSessionContent(options.content);
+  const validation = validateSessionContent(fullContent);
+  if (!validation.valid) {
+    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 });
+  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}
+`);
+  }
+  return output;
+}
+
+// src/commands/session/list.ts
+import { readdir, readFile } from "fs/promises";
+import { join as join6 } from "path";
+async function loadSessionsFromDir(dir, status) {
+  try {
+    const files = await readdir(dir);
+    const sessions = [];
+    for (const file of files) {
+      if (!file.endsWith(".md")) continue;
+      const id = file.replace(".md", "");
+      const filePath = join6(dir, file);
+      const content = await readFile(filePath, "utf-8");
+      const metadata = parseSessionMetadata(content);
+      sessions.push({
+        id,
+        status,
+        path: filePath,
+        metadata
+      });
+    }
+    return sessions;
+  } catch (error) {
+    if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+      return [];
+    }
+    throw error;
+  }
+}
+function formatTextOutput(sessions, _status) {
+  if (sessions.length === 0) {
+    return `  (no sessions)`;
+  }
+  return sessions.map((s) => {
+    const priority = s.metadata.priority !== "medium" ? ` [${s.metadata.priority}]` : "";
+    const tags = s.metadata.tags.length > 0 ? ` (${s.metadata.tags.join(", ")})` : "";
+    return `  ${s.id}${priority}${tags}`;
+  }).join("\n");
+}
+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: []
+  };
+  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);
+  }
+  if (options.format === "json") {
+    return JSON.stringify(allSessions, 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"));
+    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";
+
+// src/session/pickup.ts
+function buildClaimPaths(sessionId, config) {
+  return {
+    source: `${config.todoDir}/${sessionId}.md`,
+    target: `${config.doingDir}/${sessionId}.md`
+  };
+}
+function classifyClaimError(error, sessionId) {
+  if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+    return new SessionNotAvailableError(sessionId);
+  }
+  throw error;
+}
+function selectBestSession(sessions) {
+  if (sessions.length === 0) {
+    return null;
+  }
+  const sorted = [...sessions].sort((a, b) => {
+    const priorityA = PRIORITY_ORDER[a.metadata.priority];
+    const priorityB = PRIORITY_ORDER[b.metadata.priority];
+    if (priorityA !== priorityB) {
+      return priorityA - priorityB;
+    }
+    const dateA = parseSessionId(a.id);
+    const dateB = parseSessionId(b.id);
+    if (!dateA && !dateB) return 0;
+    if (!dateA) return 1;
+    if (!dateB) return -1;
+    return dateA.getTime() - dateB.getTime();
+  });
+  return sorted[0];
+}
+
+// src/commands/session/pickup.ts
+async function loadTodoSessions(config) {
+  try {
+    const files = await readdir2(config.todoDir);
+    const sessions = [];
+    for (const file of files) {
+      if (!file.endsWith(".md")) continue;
+      const id = file.replace(".md", "");
+      const filePath = join7(config.todoDir, file);
+      const content = await readFile2(filePath, "utf-8");
+      const metadata = parseSessionMetadata(content);
+      sessions.push({
+        id,
+        status: "todo",
+        path: filePath,
+        metadata
+      });
+    }
+    return sessions;
+  } catch (error) {
+    if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+      return [];
+    }
+    throw error;
+  }
+}
+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;
+  let sessionId;
+  if (options.auto) {
+    const sessions = await loadTodoSessions(config);
+    const selected = selectBestSession(sessions);
+    if (!selected) {
+      throw new NoSessionsAvailableError();
+    }
+    sessionId = selected.id;
+  } else if (options.sessionId) {
+    sessionId = options.sessionId;
+  } else {
+    throw new Error("Either session ID or --auto flag is required");
+  }
+  const paths = buildClaimPaths(sessionId, config);
+  await mkdir3(config.doingDir, { recursive: true });
+  try {
+    await rename2(paths.source, paths.target);
+  } catch (error) {
+    throw classifyClaimError(error, sessionId);
+  }
+  const content = await readFile2(paths.target, "utf-8");
+  const output = formatShowOutput(content, { status: "doing" });
+  return `Claimed session <PICKUP_ID>${sessionId}</PICKUP_ID>
+
+${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";
+var DEFAULT_KEEP_COUNT = 5;
+var PruneValidationError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "PruneValidationError";
+  }
+};
+function validatePruneOptions(options) {
+  if (options.keep !== void 0) {
+    if (!Number.isInteger(options.keep) || options.keep < 1) {
+      throw new PruneValidationError(
+        `Invalid --keep value: ${options.keep}. Must be a positive integer.`
+      );
+    }
+  }
+}
+async function loadArchiveSessions(config) {
+  try {
+    const files = await readdir3(config.archiveDir);
+    const sessions = [];
+    for (const file of files) {
+      if (!file.endsWith(".md")) continue;
+      const id = file.replace(".md", "");
+      const filePath = join8(config.archiveDir, file);
+      const content = await readFile3(filePath, "utf-8");
+      const metadata = parseSessionMetadata(content);
+      sessions.push({
+        id,
+        status: "archive",
+        path: filePath,
+        metadata
+      });
+    }
+    return sessions;
+  } catch (error) {
+    if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+      return [];
+    }
+    throw error;
+  }
+}
+function selectSessionsToPrune(sessions, keep) {
+  const sorted = sortSessions(sessions);
+  if (sorted.length <= keep) {
+    return [];
+  }
+  return sorted.slice(keep);
+}
+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 sessions = await loadArchiveSessions(config);
+  const toPrune = selectSessionsToPrune(sessions, keep);
+  if (toPrune.length === 0) {
+    return `No sessions to prune. ${sessions.length} sessions kept.`;
+  }
+  if (dryRun) {
+    const lines2 = [
+      `Would delete ${toPrune.length} sessions:`,
+      ...toPrune.map((s) => `  - ${s.id}`),
+      "",
+      `${sessions.length - toPrune.length} sessions would be kept.`
+    ];
+    return lines2.join("\n");
+  }
+  for (const session of toPrune) {
+    await unlink2(session.path);
+  }
+  const lines = [
+    `Deleted ${toPrune.length} sessions:`,
+    ...toPrune.map((s) => `  - ${s.id}`),
+    "",
+    `${sessions.length - toPrune.length} sessions kept.`
+  ];
+  return lines.join("\n");
+}
+
+// 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) {
+  return {
+    source: `${config.doingDir}/${sessionId}.md`,
+    target: `${config.todoDir}/${sessionId}.md`
+  };
+}
+function findCurrentSession(doingSessions) {
+  if (doingSessions.length === 0) {
+    return null;
+  }
+  const sorted = [...doingSessions].sort((a, b) => {
+    const dateA = parseSessionId(a.id);
+    const dateB = parseSessionId(b.id);
+    if (!dateA && !dateB) return 0;
+    if (!dateA) return 1;
+    if (!dateB) return -1;
+    return dateB.getTime() - dateA.getTime();
+  });
+  return sorted[0];
+}
+
+// src/commands/session/release.ts
+async function loadDoingSessions(config) {
+  try {
+    const files = await readdir4(config.doingDir);
+    return files.filter((file) => file.endsWith(".md")).map((file) => ({ id: file.replace(".md", "") }));
+  } catch (error) {
+    if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+      return [];
+    }
+    throw error;
+  }
+}
+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;
+  let sessionId;
+  if (options.sessionId) {
+    sessionId = options.sessionId;
+  } else {
+    const sessions = await loadDoingSessions(config);
+    const current = findCurrentSession(sessions);
+    if (!current) {
+      throw new SessionNotClaimedError("(none)");
+    }
+    sessionId = current.id;
+  }
+  const paths = buildReleasePaths(sessionId, config);
+  try {
+    await rename3(paths.source, paths.target);
+  } catch (error) {
+    if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+      throw new SessionNotClaimedError(sessionId);
+    }
+    throw error;
+  }
+  return `Released session: ${sessionId}
+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];
+    try {
+      const stats = await stat3(filePath);
+      if (stats.isFile()) {
+        return { path: filePath, status: SEARCH_ORDER[i] };
+      }
+    } catch {
+    }
+  }
+  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);
+  const found = await findExistingPath(paths, config);
+  if (!found) {
+    throw new SessionNotFoundError(options.sessionId);
+  }
+  const content = await readFile4(found.path, "utf-8");
+  return formatShowOutput(content, { status: found.status });
+}
+
+// src/domains/session/help.ts
+var SESSION_FORMAT_HELP = `
+Session File Format:
+  Sessions are markdown files with YAML frontmatter for metadata.
+
+  ---
+  priority: high | medium | low
+  tags: [tag1, tag2]
+  ---
+  # Session Title
+
+  Session content...
+
+Workflow:
+  1. handoff  - Create session (todo)
+  2. pickup   - Claim session (todo -> doing)
+  3. release  - Return session (doing -> todo)
+  4. delete   - Remove session
+`;
+var HANDOFF_FRONTMATTER_HELP = `
+Usage:
+  Option 1: Pipe content with frontmatter via stdin
+  Option 2: Run without stdin, then edit the created file directly
+
+Frontmatter Format:
+  ---
+  priority: high      # high | medium | low (default: medium)
+  tags: [feat, api]   # optional labels for categorization
+  ---
+  # Your session content here...
+
+Output Tags (for automation):
+  <HANDOFF_ID>session-id</HANDOFF_ID>     - Session identifier
+  <SESSION_FILE>/path/to/file</SESSION_FILE> - Absolute path to edit
+
+Examples:
+  # With stdin content:
+  echo '---
+  priority: high
+  ---
+  # Fix login' | spx session handoff
+
+  # Without stdin (creates empty session, edit file directly):
+  spx session handoff
+`;
+var PICKUP_SELECTION_HELP = `
+Selection Logic (--auto):
+  Sessions are selected by priority, then age (FIFO):
+    1. high priority first
+    2. medium priority second
+    3. low priority last
+    4. Within same priority: oldest session first
+
+Output:
+  <PICKUP_ID>session-id</PICKUP_ID> tag for automation parsing
+`;
+
+// src/domains/session/index.ts
+async function readStdin() {
+  if (process.stdin.isTTY) {
+    return void 0;
+  }
+  return new Promise((resolve2) => {
+    let data = "";
+    process.stdin.setEncoding("utf-8");
+    process.stdin.on("data", (chunk) => {
+      data += chunk;
+    });
+    process.stdin.on("end", () => {
+      resolve2(data.trim() || void 0);
+    });
+    process.stdin.on("error", () => {
+      resolve2(void 0);
+    });
+  });
+}
+function handleError(error) {
+  console.error("Error:", error instanceof Error ? error.message : String(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) => {
+    try {
+      const output = await listCommand({
+        status: options.status,
+        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 (id, options) => {
+    try {
+      const output = await showCommand({
+        sessionId: id,
+        sessionsDir: options.sessionsDir
+      });
+      console.log(output);
+    } catch (error) {
+      handleError(error);
+    }
+  });
+  sessionCmd.command("pickup [id]").description("Claim a session (move from todo to doing)").option("--auto", "Auto-select highest priority session").option("--sessions-dir <path>", "Custom sessions directory").addHelpText("after", PICKUP_SELECTION_HELP).action(async (id, options) => {
+    try {
+      if (!id && !options.auto) {
+        console.error("Error: Either session ID or --auto flag is required");
+        process.exit(1);
+      }
+      const output = await pickupCommand({
+        sessionId: id,
+        auto: options.auto,
+        sessionsDir: options.sessionsDir
+      });
+      console.log(output);
+    } catch (error) {
+      handleError(error);
+    }
+  });
+  sessionCmd.command("release [id]").description("Release a session (move from doing to todo)").option("--sessions-dir <path>", "Custom sessions directory").action(async (id, options) => {
+    try {
+      const output = await releaseCommand({
+        sessionId: id,
+        sessionsDir: options.sessionsDir
+      });
+      console.log(output);
+    } catch (error) {
+      handleError(error);
+    }
+  });
+  sessionCmd.command("handoff").description("Create a handoff session (reads content with frontmatter from stdin)").option("--sessions-dir <path>", "Custom sessions directory").addHelpText("after", HANDOFF_FRONTMATTER_HELP).action(async (options) => {
+    try {
+      const content = await readStdin();
+      const output = await handoffCommand({
+        content,
+        sessionsDir: options.sessionsDir
+      });
+      console.log(output);
+    } catch (error) {
+      handleError(error);
+    }
+  });
+  sessionCmd.command("delete <id>").description("Delete a session").option("--sessions-dir <path>", "Custom sessions directory").action(async (id, options) => {
+    try {
+      const output = await deleteCommand({
+        sessionId: id,
+        sessionsDir: options.sessionsDir
+      });
+      console.log(output);
+    } catch (error) {
+      handleError(error);
+    }
+  });
+  sessionCmd.command("prune").description("Remove old todo sessions, keeping the most recent N").option("--keep <count>", "Number of sessions to keep (default: 5)", "5").option("--dry-run", "Show what would be deleted without deleting").option("--sessions-dir <path>", "Custom sessions directory").action(async (options) => {
+    try {
+      const keep = options.keep ? Number.parseInt(options.keep, 10) : void 0;
+      const output = await pruneCommand({
+        keep,
+        dryRun: options.dryRun,
+        sessionsDir: options.sessionsDir
+      });
+      console.log(output);
+    } catch (error) {
+      if (error instanceof PruneValidationError) {
+        console.error("Error:", error.message);
+        process.exit(1);
+      }
+      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) => {
+    try {
+      const output = await archiveCommand({
+        sessionId: id,
+        sessionsDir: options.sessionsDir
+      });
+      console.log(output);
+    } catch (error) {
+      if (error instanceof SessionAlreadyArchivedError) {
+        console.error("Error:", error.message);
+        process.exit(1);
+      }
+      handleError(error);
+    }
+  });
+}
+var sessionDomain = {
+  name: "session",
+  description: "Manage session workflow",
+  register: (program2) => {
+    const sessionCmd = program2.command("session").description("Manage session workflow").addHelpText("after", SESSION_FORMAT_HELP);
+    registerSessionCommands(sessionCmd);
+  }
+};
+
+// src/scanner/scanner.ts
+import path5 from "path";
+var Scanner = class {
+  /**
+   * Create a new Scanner instance
+   *
+   * @param projectRoot - Absolute path to the project root directory
+   * @param config - Configuration object defining directory structure
+   */
+  constructor(projectRoot, config) {
+    this.projectRoot = projectRoot;
+    this.config = config;
+  }
+  /**
+   * Scan the project for work items in the "doing" status directory
+   *
+   * Walks the configured specs/work/doing directory, filters for valid
+   * work item directories, and returns structured work item data.
+   *
+   * @returns Array of work items found in the doing directory
+   * @throws Error if the directory doesn't exist or is inaccessible
+   */
+  async scan() {
+    const doingPath = this.getDoingPath();
+    const allEntries = await walkDirectory(doingPath);
+    const workItemEntries = filterWorkItemDirectories(allEntries);
+    return buildWorkItemList(workItemEntries);
+  }
+  /**
+   * Get the full path to the "doing" status directory
+   *
+   * Constructs path from config: {projectRoot}/{specs.root}/{work.dir}/{statusDirs.doing}
+   *
+   * @returns Absolute path to the doing directory
+   */
+  getDoingPath() {
+    return path5.join(
+      this.projectRoot,
+      this.config.specs.root,
+      this.config.specs.work.dir,
+      this.config.specs.work.statusDirs.doing
+    );
+  }
+  /**
+   * Get the full path to the "backlog" status directory
+   *
+   * @returns Absolute path to the backlog directory
+   */
+  getBacklogPath() {
+    return path5.join(
+      this.projectRoot,
+      this.config.specs.root,
+      this.config.specs.work.dir,
+      this.config.specs.work.statusDirs.backlog
+    );
+  }
+  /**
+   * Get the full path to the "done" status directory
+   *
+   * @returns Absolute path to the done/archive directory
+   */
+  getDonePath() {
+    return path5.join(
+      this.projectRoot,
+      this.config.specs.root,
+      this.config.specs.work.dir,
+      this.config.specs.work.statusDirs.done
+    );
+  }
+  /**
+   * Get the full path to the specs root directory
+   *
+   * @returns Absolute path to the specs root
+   */
+  getSpecsRootPath() {
+    return path5.join(this.projectRoot, this.config.specs.root);
+  }
+  /**
+   * Get the full path to the work directory
+   *
+   * @returns Absolute path to the work directory
+   */
+  getWorkPath() {
+    return path5.join(
+      this.projectRoot,
+      this.config.specs.root,
+      this.config.specs.work.dir
+    );
+  }
+};
+
+// src/status/state.ts
+import { access, readdir as readdir5, stat as stat4 } from "fs/promises";
+import path6 from "path";
+function determineStatus(flags) {
+  if (!flags.hasTestsDir) {
+    return "OPEN";
+  }
+  if (flags.hasDoneMd) {
+    return "DONE";
+  }
+  if (flags.testsIsEmpty) {
+    return "OPEN";
+  }
+  return "IN_PROGRESS";
+}
+var StatusDeterminationError = class extends Error {
+  constructor(workItemPath, cause) {
+    const errorMessage = cause instanceof Error ? cause.message : String(cause);
+    super(`Failed to determine status for ${workItemPath}: ${errorMessage}`);
+    this.workItemPath = workItemPath;
+    this.cause = cause;
+    this.name = "StatusDeterminationError";
+  }
+};
+async function getWorkItemStatus(workItemPath) {
+  try {
+    try {
+      await access(workItemPath);
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        throw new Error(`Work item not found: ${workItemPath}`);
+      }
+      throw error;
+    }
+    const testsPath = path6.join(workItemPath, "tests");
+    let hasTests;
+    try {
+      await access(testsPath);
+      hasTests = true;
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        hasTests = false;
+      } else {
+        throw error;
+      }
+    }
+    if (!hasTests) {
+      return determineStatus({
+        hasTestsDir: false,
+        hasDoneMd: false,
+        testsIsEmpty: true
+      });
+    }
+    const entries = await readdir5(testsPath);
+    const hasDone = entries.includes("DONE.md");
+    if (hasDone) {
+      const donePath = path6.join(testsPath, "DONE.md");
+      const stats = await stat4(donePath);
+      if (!stats.isFile()) {
+        return determineStatus({
+          hasTestsDir: true,
+          hasDoneMd: false,
+          testsIsEmpty: isEmptyFromEntries(entries)
+        });
+      }
+    }
+    const isEmpty = isEmptyFromEntries(entries);
+    return determineStatus({
+      hasTestsDir: true,
+      hasDoneMd: hasDone,
+      testsIsEmpty: isEmpty
+    });
+  } catch (error) {
+    throw new StatusDeterminationError(workItemPath, error);
+  }
+}
+function isEmptyFromEntries(entries) {
+  const testFiles = entries.filter((entry) => {
+    if (entry === "DONE.md") {
+      return false;
+    }
+    if (entry.startsWith(".")) {
+      return false;
+    }
+    return true;
+  });
+  return testFiles.length === 0;
+}
+
+// src/tree/build.ts
+async function buildTree(workItems, deps = {}) {
+  const getStatus = deps.getStatus || getWorkItemStatus;
+  const itemsWithStatus = await Promise.all(
+    workItems.map(async (item) => ({
+      ...item,
+      status: await getStatus(item.path)
+    }))
+  );
+  const capabilities = itemsWithStatus.filter(
+    (item) => item.kind === "capability"
+  );
+  const features = itemsWithStatus.filter((item) => item.kind === "feature");
+  const stories = itemsWithStatus.filter((item) => item.kind === "story");
+  const storyNodes = stories.map((item) => createTreeNode(item, []));
+  const featureNodes = features.map((item) => {
+    const children = storyNodes.filter((story) => isChildOf(story.path, item.path)).sort((a, b) => a.number - b.number);
+    return createTreeNode(item, children);
+  });
+  const capabilityNodes = capabilities.map((item) => {
+    const children = featureNodes.filter((feature) => isChildOf(feature.path, item.path)).sort((a, b) => a.number - b.number);
+    return createTreeNode(item, children);
+  });
+  detectOrphans(stories, featureNodes);
+  detectOrphans(features, capabilityNodes);
+  const sortedCapabilities = capabilityNodes.sort((a, b) => a.number - b.number);
+  rollupStatus(sortedCapabilities);
+  return {
+    nodes: sortedCapabilities
+  };
+}
+function createTreeNode(item, children) {
+  return {
+    kind: item.kind,
+    number: item.number,
+    slug: item.slug,
+    path: item.path,
+    status: item.status,
+    children
+  };
+}
+function isChildOf(childPath, parentPath) {
+  const normalizedChild = childPath.replace(/\/$/, "");
+  const normalizedParent = parentPath.replace(/\/$/, "");
+  if (!normalizedChild.startsWith(normalizedParent + "/")) {
+    return false;
+  }
+  const relativePath = normalizedChild.slice(normalizedParent.length + 1);
+  return !relativePath.includes("/");
+}
+function detectOrphans(items, potentialParents) {
+  for (const item of items) {
+    const hasParent = potentialParents.some((parent) => isChildOf(item.path, parent.path));
+    if (!hasParent) {
+      throw new Error(
+        `Orphan work item detected: ${item.kind} "${item.slug}" at ${item.path} has no valid parent`
+      );
+    }
+  }
+}
+function rollupStatus(nodes) {
+  for (const node of nodes) {
+    if (node.children.length > 0) {
+      rollupStatus(node.children);
+      const ownStatus = node.status;
+      const childStatuses = node.children.map((child) => child.status);
+      const allChildrenDone = childStatuses.every(
+        (status) => status === "DONE"
+      );
+      const allChildrenOpen = childStatuses.every(
+        (status) => status === "OPEN"
+      );
+      if (ownStatus === "DONE" && allChildrenDone) {
+        node.status = "DONE";
+      } else if (ownStatus === "OPEN" && allChildrenOpen) {
+        node.status = "OPEN";
+      } else {
+        node.status = "IN_PROGRESS";
+      }
+    }
+  }
+}
+
+// src/commands/spec/next.ts
+function findNextWorkItem(tree) {
+  return findFirstNonDoneLeaf(tree.nodes);
+}
+function findFirstNonDoneLeaf(nodes) {
+  for (const node of nodes) {
+    if (node.kind === LEAF_KIND) {
+      if (node.status !== "DONE") {
+        return node;
+      }
+    } else {
+      const found = findFirstNonDoneLeaf(node.children);
+      if (found) {
+        return found;
+      }
+    }
+  }
+  return null;
+}
+function formatWorkItemName(node) {
+  const displayNum = node.kind === "capability" ? node.number + 1 : node.number;
+  return `${node.kind}-${displayNum}_${node.slug}`;
+}
+async function nextCommand(options = {}) {
+  const cwd = options.cwd || process.cwd();
+  const scanner = new Scanner(cwd, DEFAULT_CONFIG);
+  const workItems = await scanner.scan();
+  if (workItems.length === 0) {
+    return `No work items found in ${DEFAULT_CONFIG.specs.root}/${DEFAULT_CONFIG.specs.work.dir}/${DEFAULT_CONFIG.specs.work.statusDirs.doing}`;
+  }
+  const tree = await buildTree(workItems);
+  const next = findNextWorkItem(tree);
+  if (!next) {
+    return "All work items are complete! \u{1F389}";
+  }
+  const parents = findParents(tree.nodes, next);
+  const lines = [];
+  lines.push("Next work item:");
+  lines.push("");
+  if (parents.capability && parents.feature) {
+    lines.push(
+      `  ${formatWorkItemName(parents.capability)} > ${formatWorkItemName(parents.feature)} > ${formatWorkItemName(next)}`
+    );
+  } else {
+    lines.push(`  ${formatWorkItemName(next)}`);
+  }
+  lines.push("");
+  lines.push(`  Status: ${next.status}`);
+  lines.push(`  Path: ${next.path}`);
+  return lines.join("\n");
+}
+function findParents(nodes, target) {
+  for (const capability of nodes) {
+    for (const feature of capability.children) {
+      for (const story of feature.children) {
+        if (story.path === target.path) {
+          return { capability, feature };
+        }
+      }
+    }
+  }
+  return {};
+}
+
+// src/reporter/json.ts
+var JSON_INDENT = 2;
+function formatJSON(tree, config) {
+  const capabilities = tree.nodes.map((node) => nodeToJSON(node));
+  const summary = calculateSummary(tree);
+  const output = {
+    config: {
+      specs: config.specs,
+      sessions: config.sessions
+    },
+    summary,
+    capabilities
+  };
+  return JSON.stringify(output, null, JSON_INDENT);
+}
+function nodeToJSON(node) {
+  const displayNumber = getDisplayNumber(node);
+  const base = {
+    kind: node.kind,
+    number: displayNumber,
+    slug: node.slug,
+    status: node.status
+  };
+  if (node.kind === "capability") {
+    return {
+      ...base,
+      features: node.children.map((child) => nodeToJSON(child))
+    };
+  } else if (node.kind === "feature") {
+    return {
+      ...base,
+      stories: node.children.map((child) => nodeToJSON(child))
+    };
+  } else {
+    return base;
+  }
+}
+function calculateSummary(tree) {
+  const summary = {
+    done: 0,
+    inProgress: 0,
+    open: 0
+  };
+  for (const capability of tree.nodes) {
+    countNode(capability, summary);
+    for (const feature of capability.children) {
+      countNode(feature, summary);
+    }
+  }
+  return summary;
+}
+function countNode(node, summary) {
+  switch (node.status) {
+    case "DONE":
+      summary.done++;
+      break;
+    case "IN_PROGRESS":
+      summary.inProgress++;
+      break;
+    case "OPEN":
+      summary.open++;
+      break;
+  }
+}
+function getDisplayNumber(node) {
+  return node.kind === "capability" ? node.number + 1 : node.number;
+}
+
+// src/reporter/markdown.ts
+function formatMarkdown(tree) {
+  const sections = [];
+  for (const node of tree.nodes) {
+    formatNode(node, 1, sections);
+  }
+  return sections.join("\n\n");
+}
+function formatNode(node, level, sections) {
+  const displayNumber = getDisplayNumber2(node);
+  const name = `${node.kind}-${displayNumber}_${node.slug}`;
+  const heading = "#".repeat(level);
+  sections.push(`${heading} ${name}`);
+  sections.push(`Status: ${node.status}`);
+  for (const child of node.children) {
+    formatNode(child, level + 1, sections);
+  }
+}
+function getDisplayNumber2(node) {
+  return node.kind === "capability" ? node.number + 1 : node.number;
+}
+
+// src/reporter/table.ts
+function formatTable(tree) {
+  const rows = [];
+  for (const node of tree.nodes) {
+    collectRows(node, 0, rows);
+  }
+  const widths = calculateColumnWidths(rows);
+  const lines = [];
+  lines.push(
+    formatRow(
+      {
+        level: "Level",
+        number: "Number",
+        name: "Name",
+        status: "Status"
+      },
+      widths
+    )
+  );
+  lines.push(
+    `|${"-".repeat(widths.level + 2)}|${"-".repeat(widths.number + 2)}|${"-".repeat(widths.name + 2)}|${"-".repeat(widths.status + 2)}|`
+  );
+  for (const row of rows) {
+    lines.push(formatRow(row, widths));
+  }
+  return lines.join("\n");
+}
+function collectRows(node, depth, rows) {
+  const indent = "  ".repeat(depth);
+  const levelName = getLevelName(node.kind);
+  const displayNumber = getDisplayNumber3(node);
+  rows.push({
+    level: `${indent}${levelName}`,
+    number: String(displayNumber),
+    name: node.slug,
+    status: node.status
+  });
+  for (const child of node.children) {
+    collectRows(child, depth + 1, rows);
+  }
+}
+function getLevelName(kind) {
+  return kind.charAt(0).toUpperCase() + kind.slice(1);
+}
+function getDisplayNumber3(node) {
+  return node.kind === "capability" ? node.number + 1 : node.number;
+}
+function calculateColumnWidths(rows) {
+  const widths = {
+    level: "Level".length,
+    number: "Number".length,
+    name: "Name".length,
+    status: "Status".length
+  };
+  for (const row of rows) {
+    widths.level = Math.max(widths.level, row.level.length);
+    widths.number = Math.max(widths.number, row.number.length);
+    widths.name = Math.max(widths.name, row.name.length);
+    widths.status = Math.max(widths.status, row.status.length);
+  }
+  return widths;
+}
+function formatRow(row, widths) {
+  return `| ${row.level.padEnd(widths.level)} | ${row.number.padEnd(widths.number)} | ${row.name.padEnd(widths.name)} | ${row.status.padEnd(widths.status)} |`;
+}
+
+// src/reporter/text.ts
+import chalk from "chalk";
+function formatText(tree) {
+  const lines = [];
+  for (const node of tree.nodes) {
+    lines.push(formatNode2(node, 0));
+  }
+  return lines.join("\n");
+}
+function formatNode2(node, indent) {
+  const lines = [];
+  const name = formatWorkItemName2(node.kind, node.number, node.slug);
+  const prefix = " ".repeat(indent);
+  const status = formatStatus(node.status);
+  const line = `${prefix}${name} ${status}`;
+  lines.push(line);
+  for (const child of node.children) {
+    lines.push(formatNode2(child, indent + 2));
+  }
+  return lines.join("\n");
+}
+function formatWorkItemName2(kind, number, slug) {
+  const displayNumber = kind === "capability" ? number + 1 : number;
+  return `${kind}-${displayNumber}_${slug}`;
+}
+function formatStatus(status) {
+  switch (status) {
+    case "DONE":
+      return chalk.green(`[${status}]`);
+    case "IN_PROGRESS":
+      return chalk.yellow(`[${status}]`);
+    case "OPEN":
+      return chalk.gray(`[${status}]`);
+    default:
+      return `[${status}]`;
+  }
+}
+
+// src/commands/spec/status.ts
+async function statusCommand(options = {}) {
+  const cwd = options.cwd || process.cwd();
+  const format2 = options.format || "text";
+  const scanner = new Scanner(cwd, DEFAULT_CONFIG);
+  let workItems;
+  try {
+    workItems = await scanner.scan();
+  } catch (error) {
+    if (error instanceof Error && error.message.includes("ENOENT")) {
+      const doingPath = `${DEFAULT_CONFIG.specs.root}/${DEFAULT_CONFIG.specs.work.dir}/${DEFAULT_CONFIG.specs.work.statusDirs.doing}`;
+      throw new Error(
+        `Directory ${doingPath} not found.
+
+This command is for legacy specs/ projects. For CODE framework projects, check the spx/ directory for specifications.`
+      );
+    }
+    throw error;
+  }
+  if (workItems.length === 0) {
+    return `No work items found in ${DEFAULT_CONFIG.specs.root}/${DEFAULT_CONFIG.specs.work.dir}/${DEFAULT_CONFIG.specs.work.statusDirs.doing}`;
+  }
+  const tree = await buildTree(workItems);
+  switch (format2) {
+    case "json":
+      return formatJSON(tree, DEFAULT_CONFIG);
+    case "markdown":
+      return formatMarkdown(tree);
+    case "table":
+      return formatTable(tree);
+    case "text":
+    default:
+      return formatText(tree);
+  }
+}
+
+// src/domains/spec/index.ts
+function registerSpecCommands(specCmd) {
+  specCmd.command("status").description("Get project status").option("--json", "Output as JSON").option("--format <format>", "Output format (text|json|markdown|table)").action(async (options) => {
+    try {
+      let format2 = "text";
+      if (options.json) {
+        format2 = "json";
+      } else if (options.format) {
+        const validFormats = ["text", "json", "markdown", "table"];
+        if (validFormats.includes(options.format)) {
+          format2 = options.format;
+        } else {
+          console.error(
+            `Error: Invalid format "${options.format}". Must be one of: ${validFormats.join(", ")}`
+          );
+          process.exit(1);
+        }
+      }
+      const output = await statusCommand({ cwd: process.cwd(), format: format2 });
+      console.log(output);
+    } catch (error) {
+      console.error(
+        "Error:",
+        error instanceof Error ? error.message : String(error)
+      );
+      process.exit(1);
+    }
+  });
+  specCmd.command("next").description("Find next work item to work on").action(async () => {
+    try {
+      const output = await nextCommand({ cwd: process.cwd() });
+      console.log(output);
+    } catch (error) {
+      console.error(
+        "Error:",
+        error instanceof Error ? error.message : String(error)
+      );
+      process.exit(1);
+    }
+  });
+}
+var specDomain = {
+  name: "spec",
+  description: "Manage spec workflow",
+  register: (program2) => {
+    const specCmd = program2.command("spec").description("Manage spec workflow");
+    registerSpecCommands(specCmd);
+  }
+};
+
+// node_modules/.pnpm/jsonc-parser@3.3.1/node_modules/jsonc-parser/lib/esm/impl/scanner.js
+function createScanner(text, ignoreTrivia = false) {
+  const len = text.length;
+  let pos = 0, value = "", tokenOffset = 0, token = 16, lineNumber = 0, lineStartOffset = 0, tokenLineStartOffset = 0, prevTokenLineStartOffset = 0, scanError = 0;
+  function scanHexDigits(count, exact) {
+    let digits = 0;
+    let value2 = 0;
+    while (digits < count || !exact) {
+      let ch = text.charCodeAt(pos);
+      if (ch >= 48 && ch <= 57) {
+        value2 = value2 * 16 + ch - 48;
+      } else if (ch >= 65 && ch <= 70) {
+        value2 = value2 * 16 + ch - 65 + 10;
+      } else if (ch >= 97 && ch <= 102) {
+        value2 = value2 * 16 + ch - 97 + 10;
+      } else {
+        break;
+      }
+      pos++;
+      digits++;
+    }
+    if (digits < count) {
+      value2 = -1;
+    }
+    return value2;
+  }
+  function setPosition(newPosition) {
+    pos = newPosition;
+    value = "";
+    tokenOffset = 0;
+    token = 16;
+    scanError = 0;
+  }
+  function scanNumber() {
+    let start = pos;
+    if (text.charCodeAt(pos) === 48) {
+      pos++;
+    } else {
+      pos++;
+      while (pos < text.length && isDigit(text.charCodeAt(pos))) {
+        pos++;
+      }
+    }
+    if (pos < text.length && text.charCodeAt(pos) === 46) {
+      pos++;
+      if (pos < text.length && isDigit(text.charCodeAt(pos))) {
+        pos++;
+        while (pos < text.length && isDigit(text.charCodeAt(pos))) {
+          pos++;
+        }
+      } else {
+        scanError = 3;
+        return text.substring(start, pos);
+      }
+    }
+    let end = pos;
+    if (pos < text.length && (text.charCodeAt(pos) === 69 || text.charCodeAt(pos) === 101)) {
+      pos++;
+      if (pos < text.length && text.charCodeAt(pos) === 43 || text.charCodeAt(pos) === 45) {
+        pos++;
+      }
+      if (pos < text.length && isDigit(text.charCodeAt(pos))) {
+        pos++;
+        while (pos < text.length && isDigit(text.charCodeAt(pos))) {
+          pos++;
+        }
+        end = pos;
+      } else {
+        scanError = 3;
+      }
+    }
+    return text.substring(start, end);
+  }
+  function scanString() {
+    let result = "", start = pos;
+    while (true) {
+      if (pos >= len) {
+        result += text.substring(start, pos);
+        scanError = 2;
+        break;
+      }
+      const ch = text.charCodeAt(pos);
+      if (ch === 34) {
+        result += text.substring(start, pos);
+        pos++;
+        break;
+      }
+      if (ch === 92) {
+        result += text.substring(start, pos);
+        pos++;
+        if (pos >= len) {
+          scanError = 2;
+          break;
+        }
+        const ch2 = text.charCodeAt(pos++);
+        switch (ch2) {
+          case 34:
+            result += '"';
+            break;
+          case 92:
+            result += "\\";
+            break;
+          case 47:
+            result += "/";
+            break;
+          case 98:
+            result += "\b";
+            break;
+          case 102:
+            result += "\f";
+            break;
+          case 110:
+            result += "\n";
+            break;
+          case 114:
+            result += "\r";
+            break;
+          case 116:
+            result += "	";
+            break;
+          case 117:
+            const ch3 = scanHexDigits(4, true);
+            if (ch3 >= 0) {
+              result += String.fromCharCode(ch3);
+            } else {
+              scanError = 4;
+            }
+            break;
+          default:
+            scanError = 5;
+        }
+        start = pos;
+        continue;
+      }
+      if (ch >= 0 && ch <= 31) {
+        if (isLineBreak(ch)) {
+          result += text.substring(start, pos);
+          scanError = 2;
+          break;
+        } else {
+          scanError = 6;
+        }
+      }
+      pos++;
+    }
+    return result;
+  }
+  function scanNext() {
+    value = "";
+    scanError = 0;
+    tokenOffset = pos;
+    lineStartOffset = lineNumber;
+    prevTokenLineStartOffset = tokenLineStartOffset;
+    if (pos >= len) {
+      tokenOffset = len;
+      return token = 17;
+    }
+    let code = text.charCodeAt(pos);
+    if (isWhiteSpace(code)) {
+      do {
+        pos++;
+        value += String.fromCharCode(code);
+        code = text.charCodeAt(pos);
+      } while (isWhiteSpace(code));
+      return token = 15;
+    }
+    if (isLineBreak(code)) {
+      pos++;
+      value += String.fromCharCode(code);
+      if (code === 13 && text.charCodeAt(pos) === 10) {
+        pos++;
+        value += "\n";
+      }
+      lineNumber++;
+      tokenLineStartOffset = pos;
+      return token = 14;
+    }
+    switch (code) {
+      // tokens: []{}:,
+      case 123:
+        pos++;
+        return token = 1;
+      case 125:
+        pos++;
+        return token = 2;
+      case 91:
+        pos++;
+        return token = 3;
+      case 93:
+        pos++;
+        return token = 4;
+      case 58:
+        pos++;
+        return token = 6;
+      case 44:
+        pos++;
+        return token = 5;
+      // strings
+      case 34:
+        pos++;
+        value = scanString();
+        return token = 10;
+      // comments
+      case 47:
+        const start = pos - 1;
+        if (text.charCodeAt(pos + 1) === 47) {
+          pos += 2;
+          while (pos < len) {
+            if (isLineBreak(text.charCodeAt(pos))) {
+              break;
+            }
+            pos++;
+          }
+          value = text.substring(start, pos);
+          return token = 12;
+        }
+        if (text.charCodeAt(pos + 1) === 42) {
+          pos += 2;
+          const safeLength = len - 1;
+          let commentClosed = false;
+          while (pos < safeLength) {
+            const ch = text.charCodeAt(pos);
+            if (ch === 42 && text.charCodeAt(pos + 1) === 47) {
+              pos += 2;
+              commentClosed = true;
+              break;
+            }
+            pos++;
+            if (isLineBreak(ch)) {
+              if (ch === 13 && text.charCodeAt(pos) === 10) {
+                pos++;
+              }
+              lineNumber++;
+              tokenLineStartOffset = pos;
+            }
+          }
+          if (!commentClosed) {
+            pos++;
+            scanError = 1;
+          }
+          value = text.substring(start, pos);
+          return token = 13;
+        }
+        value += String.fromCharCode(code);
+        pos++;
+        return token = 16;
+      // numbers
+      case 45:
+        value += String.fromCharCode(code);
+        pos++;
+        if (pos === len || !isDigit(text.charCodeAt(pos))) {
+          return token = 16;
+        }
+      // found a minus, followed by a number so
+      // we fall through to proceed with scanning
+      // numbers
+      case 48:
+      case 49:
+      case 50:
+      case 51:
+      case 52:
+      case 53:
+      case 54:
+      case 55:
+      case 56:
+      case 57:
+        value += scanNumber();
+        return token = 11;
+      // literals and unknown symbols
+      default:
+        while (pos < len && isUnknownContentCharacter(code)) {
+          pos++;
+          code = text.charCodeAt(pos);
+        }
+        if (tokenOffset !== pos) {
+          value = text.substring(tokenOffset, pos);
+          switch (value) {
+            case "true":
+              return token = 8;
+            case "false":
+              return token = 9;
+            case "null":
+              return token = 7;
+          }
+          return token = 16;
+        }
+        value += String.fromCharCode(code);
+        pos++;
+        return token = 16;
+    }
+  }
+  function isUnknownContentCharacter(code) {
+    if (isWhiteSpace(code) || isLineBreak(code)) {
+      return false;
+    }
+    switch (code) {
+      case 125:
+      case 93:
+      case 123:
+      case 91:
+      case 34:
+      case 58:
+      case 44:
+      case 47:
+        return false;
+    }
+    return true;
+  }
+  function scanNextNonTrivia() {
+    let result;
+    do {
+      result = scanNext();
+    } while (result >= 12 && result <= 15);
+    return result;
+  }
+  return {
+    setPosition,
+    getPosition: () => pos,
+    scan: ignoreTrivia ? scanNextNonTrivia : scanNext,
+    getToken: () => token,
+    getTokenValue: () => value,
+    getTokenOffset: () => tokenOffset,
+    getTokenLength: () => pos - tokenOffset,
+    getTokenStartLine: () => lineStartOffset,
+    getTokenStartCharacter: () => tokenOffset - prevTokenLineStartOffset,
+    getTokenError: () => scanError
+  };
+}
+function isWhiteSpace(ch) {
+  return ch === 32 || ch === 9;
+}
+function isLineBreak(ch) {
+  return ch === 10 || ch === 13;
+}
+function isDigit(ch) {
+  return ch >= 48 && ch <= 57;
+}
+var CharacterCodes;
+(function(CharacterCodes2) {
+  CharacterCodes2[CharacterCodes2["lineFeed"] = 10] = "lineFeed";
+  CharacterCodes2[CharacterCodes2["carriageReturn"] = 13] = "carriageReturn";
+  CharacterCodes2[CharacterCodes2["space"] = 32] = "space";
+  CharacterCodes2[CharacterCodes2["_0"] = 48] = "_0";
+  CharacterCodes2[CharacterCodes2["_1"] = 49] = "_1";
+  CharacterCodes2[CharacterCodes2["_2"] = 50] = "_2";
+  CharacterCodes2[CharacterCodes2["_3"] = 51] = "_3";
+  CharacterCodes2[CharacterCodes2["_4"] = 52] = "_4";
+  CharacterCodes2[CharacterCodes2["_5"] = 53] = "_5";
+  CharacterCodes2[CharacterCodes2["_6"] = 54] = "_6";
+  CharacterCodes2[CharacterCodes2["_7"] = 55] = "_7";
+  CharacterCodes2[CharacterCodes2["_8"] = 56] = "_8";
+  CharacterCodes2[CharacterCodes2["_9"] = 57] = "_9";
+  CharacterCodes2[CharacterCodes2["a"] = 97] = "a";
+  CharacterCodes2[CharacterCodes2["b"] = 98] = "b";
+  CharacterCodes2[CharacterCodes2["c"] = 99] = "c";
+  CharacterCodes2[CharacterCodes2["d"] = 100] = "d";
+  CharacterCodes2[CharacterCodes2["e"] = 101] = "e";
+  CharacterCodes2[CharacterCodes2["f"] = 102] = "f";
+  CharacterCodes2[CharacterCodes2["g"] = 103] = "g";
+  CharacterCodes2[CharacterCodes2["h"] = 104] = "h";
+  CharacterCodes2[CharacterCodes2["i"] = 105] = "i";
+  CharacterCodes2[CharacterCodes2["j"] = 106] = "j";
+  CharacterCodes2[CharacterCodes2["k"] = 107] = "k";
+  CharacterCodes2[CharacterCodes2["l"] = 108] = "l";
+  CharacterCodes2[CharacterCodes2["m"] = 109] = "m";
+  CharacterCodes2[CharacterCodes2["n"] = 110] = "n";
+  CharacterCodes2[CharacterCodes2["o"] = 111] = "o";
+  CharacterCodes2[CharacterCodes2["p"] = 112] = "p";
+  CharacterCodes2[CharacterCodes2["q"] = 113] = "q";
+  CharacterCodes2[CharacterCodes2["r"] = 114] = "r";
+  CharacterCodes2[CharacterCodes2["s"] = 115] = "s";
+  CharacterCodes2[CharacterCodes2["t"] = 116] = "t";
+  CharacterCodes2[CharacterCodes2["u"] = 117] = "u";
+  CharacterCodes2[CharacterCodes2["v"] = 118] = "v";
+  CharacterCodes2[CharacterCodes2["w"] = 119] = "w";
+  CharacterCodes2[CharacterCodes2["x"] = 120] = "x";
+  CharacterCodes2[CharacterCodes2["y"] = 121] = "y";
+  CharacterCodes2[CharacterCodes2["z"] = 122] = "z";
+  CharacterCodes2[CharacterCodes2["A"] = 65] = "A";
+  CharacterCodes2[CharacterCodes2["B"] = 66] = "B";
+  CharacterCodes2[CharacterCodes2["C"] = 67] = "C";
+  CharacterCodes2[CharacterCodes2["D"] = 68] = "D";
+  CharacterCodes2[CharacterCodes2["E"] = 69] = "E";
+  CharacterCodes2[CharacterCodes2["F"] = 70] = "F";
+  CharacterCodes2[CharacterCodes2["G"] = 71] = "G";
+  CharacterCodes2[CharacterCodes2["H"] = 72] = "H";
+  CharacterCodes2[CharacterCodes2["I"] = 73] = "I";
+  CharacterCodes2[CharacterCodes2["J"] = 74] = "J";
+  CharacterCodes2[CharacterCodes2["K"] = 75] = "K";
+  CharacterCodes2[CharacterCodes2["L"] = 76] = "L";
+  CharacterCodes2[CharacterCodes2["M"] = 77] = "M";
+  CharacterCodes2[CharacterCodes2["N"] = 78] = "N";
+  CharacterCodes2[CharacterCodes2["O"] = 79] = "O";
+  CharacterCodes2[CharacterCodes2["P"] = 80] = "P";
+  CharacterCodes2[CharacterCodes2["Q"] = 81] = "Q";
+  CharacterCodes2[CharacterCodes2["R"] = 82] = "R";
+  CharacterCodes2[CharacterCodes2["S"] = 83] = "S";
+  CharacterCodes2[CharacterCodes2["T"] = 84] = "T";
+  CharacterCodes2[CharacterCodes2["U"] = 85] = "U";
+  CharacterCodes2[CharacterCodes2["V"] = 86] = "V";
+  CharacterCodes2[CharacterCodes2["W"] = 87] = "W";
+  CharacterCodes2[CharacterCodes2["X"] = 88] = "X";
+  CharacterCodes2[CharacterCodes2["Y"] = 89] = "Y";
+  CharacterCodes2[CharacterCodes2["Z"] = 90] = "Z";
+  CharacterCodes2[CharacterCodes2["asterisk"] = 42] = "asterisk";
+  CharacterCodes2[CharacterCodes2["backslash"] = 92] = "backslash";
+  CharacterCodes2[CharacterCodes2["closeBrace"] = 125] = "closeBrace";
+  CharacterCodes2[CharacterCodes2["closeBracket"] = 93] = "closeBracket";
+  CharacterCodes2[CharacterCodes2["colon"] = 58] = "colon";
+  CharacterCodes2[CharacterCodes2["comma"] = 44] = "comma";
+  CharacterCodes2[CharacterCodes2["dot"] = 46] = "dot";
+  CharacterCodes2[CharacterCodes2["doubleQuote"] = 34] = "doubleQuote";
+  CharacterCodes2[CharacterCodes2["minus"] = 45] = "minus";
+  CharacterCodes2[CharacterCodes2["openBrace"] = 123] = "openBrace";
+  CharacterCodes2[CharacterCodes2["openBracket"] = 91] = "openBracket";
+  CharacterCodes2[CharacterCodes2["plus"] = 43] = "plus";
+  CharacterCodes2[CharacterCodes2["slash"] = 47] = "slash";
+  CharacterCodes2[CharacterCodes2["formFeed"] = 12] = "formFeed";
+  CharacterCodes2[CharacterCodes2["tab"] = 9] = "tab";
+})(CharacterCodes || (CharacterCodes = {}));
+
+// node_modules/.pnpm/jsonc-parser@3.3.1/node_modules/jsonc-parser/lib/esm/impl/string-intern.js
+var cachedSpaces = new Array(20).fill(0).map((_, index) => {
+  return " ".repeat(index);
+});
+var maxCachedValues = 200;
+var cachedBreakLinesWithSpaces = {
+  " ": {
+    "\n": new Array(maxCachedValues).fill(0).map((_, index) => {
+      return "\n" + " ".repeat(index);
+    }),
+    "\r": new Array(maxCachedValues).fill(0).map((_, index) => {
+      return "\r" + " ".repeat(index);
+    }),
+    "\r\n": new Array(maxCachedValues).fill(0).map((_, index) => {
+      return "\r\n" + " ".repeat(index);
+    })
+  },
+  "	": {
+    "\n": new Array(maxCachedValues).fill(0).map((_, index) => {
+      return "\n" + "	".repeat(index);
+    }),
+    "\r": new Array(maxCachedValues).fill(0).map((_, index) => {
+      return "\r" + "	".repeat(index);
+    }),
+    "\r\n": new Array(maxCachedValues).fill(0).map((_, index) => {
+      return "\r\n" + "	".repeat(index);
+    })
+  }
+};
+
+// node_modules/.pnpm/jsonc-parser@3.3.1/node_modules/jsonc-parser/lib/esm/impl/parser.js
+var ParseOptions;
+(function(ParseOptions2) {
+  ParseOptions2.DEFAULT = {
+    allowTrailingComma: false
+  };
+})(ParseOptions || (ParseOptions = {}));
+function parse(text, errors = [], options = ParseOptions.DEFAULT) {
+  let currentProperty = null;
+  let currentParent = [];
+  const previousParents = [];
+  function onValue(value) {
+    if (Array.isArray(currentParent)) {
+      currentParent.push(value);
+    } else if (currentProperty !== null) {
+      currentParent[currentProperty] = value;
+    }
+  }
+  const visitor = {
+    onObjectBegin: () => {
+      const object = {};
+      onValue(object);
+      previousParents.push(currentParent);
+      currentParent = object;
+      currentProperty = null;
+    },
+    onObjectProperty: (name) => {
+      currentProperty = name;
+    },
+    onObjectEnd: () => {
+      currentParent = previousParents.pop();
+    },
+    onArrayBegin: () => {
+      const array = [];
+      onValue(array);
+      previousParents.push(currentParent);
+      currentParent = array;
+      currentProperty = null;
+    },
+    onArrayEnd: () => {
+      currentParent = previousParents.pop();
+    },
+    onLiteralValue: onValue,
+    onError: (error, offset, length) => {
+      errors.push({ error, offset, length });
+    }
+  };
+  visit(text, visitor, options);
+  return currentParent[0];
+}
+function visit(text, visitor, options = ParseOptions.DEFAULT) {
+  const _scanner = createScanner(text, false);
+  const _jsonPath = [];
+  let suppressedCallbacks = 0;
+  function toNoArgVisit(visitFunction) {
+    return visitFunction ? () => suppressedCallbacks === 0 && visitFunction(_scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter()) : () => true;
+  }
+  function toOneArgVisit(visitFunction) {
+    return visitFunction ? (arg) => suppressedCallbacks === 0 && visitFunction(arg, _scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter()) : () => true;
+  }
+  function toOneArgVisitWithPath(visitFunction) {
+    return visitFunction ? (arg) => suppressedCallbacks === 0 && visitFunction(arg, _scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter(), () => _jsonPath.slice()) : () => true;
+  }
+  function toBeginVisit(visitFunction) {
+    return visitFunction ? () => {
+      if (suppressedCallbacks > 0) {
+        suppressedCallbacks++;
+      } else {
+        let cbReturn = visitFunction(_scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter(), () => _jsonPath.slice());
+        if (cbReturn === false) {
+          suppressedCallbacks = 1;
+        }
+      }
+    } : () => true;
+  }
+  function toEndVisit(visitFunction) {
+    return visitFunction ? () => {
+      if (suppressedCallbacks > 0) {
+        suppressedCallbacks--;
+      }
+      if (suppressedCallbacks === 0) {
+        visitFunction(_scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter());
+      }
+    } : () => true;
+  }
+  const onObjectBegin = toBeginVisit(visitor.onObjectBegin), onObjectProperty = toOneArgVisitWithPath(visitor.onObjectProperty), onObjectEnd = toEndVisit(visitor.onObjectEnd), onArrayBegin = toBeginVisit(visitor.onArrayBegin), onArrayEnd = toEndVisit(visitor.onArrayEnd), onLiteralValue = toOneArgVisitWithPath(visitor.onLiteralValue), onSeparator = toOneArgVisit(visitor.onSeparator), onComment = toNoArgVisit(visitor.onComment), onError = toOneArgVisit(visitor.onError);
+  const disallowComments = options && options.disallowComments;
+  const allowTrailingComma = options && options.allowTrailingComma;
+  function scanNext() {
+    while (true) {
+      const token = _scanner.scan();
+      switch (_scanner.getTokenError()) {
+        case 4:
+          handleError2(
+            14
+            /* ParseErrorCode.InvalidUnicode */
+          );
+          break;
+        case 5:
+          handleError2(
+            15
+            /* ParseErrorCode.InvalidEscapeCharacter */
+          );
+          break;
+        case 3:
+          handleError2(
+            13
+            /* ParseErrorCode.UnexpectedEndOfNumber */
+          );
+          break;
+        case 1:
+          if (!disallowComments) {
+            handleError2(
+              11
+              /* ParseErrorCode.UnexpectedEndOfComment */
+            );
+          }
+          break;
+        case 2:
+          handleError2(
+            12
+            /* ParseErrorCode.UnexpectedEndOfString */
+          );
+          break;
+        case 6:
+          handleError2(
+            16
+            /* ParseErrorCode.InvalidCharacter */
+          );
+          break;
+      }
+      switch (token) {
+        case 12:
+        case 13:
+          if (disallowComments) {
+            handleError2(
+              10
+              /* ParseErrorCode.InvalidCommentToken */
+            );
+          } else {
+            onComment();
+          }
+          break;
+        case 16:
+          handleError2(
+            1
+            /* ParseErrorCode.InvalidSymbol */
+          );
+          break;
+        case 15:
+        case 14:
+          break;
+        default:
+          return token;
+      }
+    }
+  }
+  function handleError2(error, skipUntilAfter = [], skipUntil = []) {
+    onError(error);
+    if (skipUntilAfter.length + skipUntil.length > 0) {
+      let token = _scanner.getToken();
+      while (token !== 17) {
+        if (skipUntilAfter.indexOf(token) !== -1) {
+          scanNext();
+          break;
+        } else if (skipUntil.indexOf(token) !== -1) {
+          break;
+        }
+        token = scanNext();
+      }
+    }
+  }
+  function parseString(isValue) {
+    const value = _scanner.getTokenValue();
+    if (isValue) {
+      onLiteralValue(value);
+    } else {
+      onObjectProperty(value);
+      _jsonPath.push(value);
+    }
+    scanNext();
+    return true;
+  }
+  function parseLiteral() {
+    switch (_scanner.getToken()) {
+      case 11:
+        const tokenValue = _scanner.getTokenValue();
+        let value = Number(tokenValue);
+        if (isNaN(value)) {
+          handleError2(
+            2
+            /* ParseErrorCode.InvalidNumberFormat */
+          );
+          value = 0;
+        }
+        onLiteralValue(value);
+        break;
+      case 7:
+        onLiteralValue(null);
+        break;
+      case 8:
+        onLiteralValue(true);
+        break;
+      case 9:
+        onLiteralValue(false);
+        break;
+      default:
+        return false;
+    }
+    scanNext();
+    return true;
+  }
+  function parseProperty() {
+    if (_scanner.getToken() !== 10) {
+      handleError2(3, [], [
+        2,
+        5
+        /* SyntaxKind.CommaToken */
+      ]);
+      return false;
+    }
+    parseString(false);
+    if (_scanner.getToken() === 6) {
+      onSeparator(":");
+      scanNext();
+      if (!parseValue()) {
+        handleError2(4, [], [
+          2,
+          5
+          /* SyntaxKind.CommaToken */
+        ]);
+      }
+    } else {
+      handleError2(5, [], [
+        2,
+        5
+        /* SyntaxKind.CommaToken */
+      ]);
+    }
+    _jsonPath.pop();
+    return true;
+  }
+  function parseObject() {
+    onObjectBegin();
+    scanNext();
+    let needsComma = false;
+    while (_scanner.getToken() !== 2 && _scanner.getToken() !== 17) {
+      if (_scanner.getToken() === 5) {
+        if (!needsComma) {
+          handleError2(4, [], []);
+        }
+        onSeparator(",");
+        scanNext();
+        if (_scanner.getToken() === 2 && allowTrailingComma) {
+          break;
+        }
+      } else if (needsComma) {
+        handleError2(6, [], []);
+      }
+      if (!parseProperty()) {
+        handleError2(4, [], [
+          2,
+          5
+          /* SyntaxKind.CommaToken */
+        ]);
+      }
+      needsComma = true;
+    }
+    onObjectEnd();
+    if (_scanner.getToken() !== 2) {
+      handleError2(7, [
+        2
+        /* SyntaxKind.CloseBraceToken */
+      ], []);
+    } else {
+      scanNext();
+    }
+    return true;
+  }
+  function parseArray() {
+    onArrayBegin();
+    scanNext();
+    let isFirstElement = true;
+    let needsComma = false;
+    while (_scanner.getToken() !== 4 && _scanner.getToken() !== 17) {
+      if (_scanner.getToken() === 5) {
+        if (!needsComma) {
+          handleError2(4, [], []);
+        }
+        onSeparator(",");
+        scanNext();
+        if (_scanner.getToken() === 4 && allowTrailingComma) {
+          break;
+        }
+      } else if (needsComma) {
+        handleError2(6, [], []);
+      }
+      if (isFirstElement) {
+        _jsonPath.push(0);
+        isFirstElement = false;
+      } else {
+        _jsonPath[_jsonPath.length - 1]++;
+      }
+      if (!parseValue()) {
+        handleError2(4, [], [
+          4,
+          5
+          /* SyntaxKind.CommaToken */
+        ]);
+      }
+      needsComma = true;
+    }
+    onArrayEnd();
+    if (!isFirstElement) {
+      _jsonPath.pop();
+    }
+    if (_scanner.getToken() !== 4) {
+      handleError2(8, [
+        4
+        /* SyntaxKind.CloseBracketToken */
+      ], []);
+    } else {
+      scanNext();
+    }
+    return true;
+  }
+  function parseValue() {
+    switch (_scanner.getToken()) {
+      case 3:
+        return parseArray();
+      case 1:
+        return parseObject();
+      case 10:
+        return parseString(true);
+      default:
+        return parseLiteral();
+    }
+  }
+  scanNext();
+  if (_scanner.getToken() === 17) {
+    if (options.allowEmptyContent) {
+      return true;
+    }
+    handleError2(4, [], []);
+    return false;
+  }
+  if (!parseValue()) {
+    handleError2(4, [], []);
+    return false;
+  }
+  if (_scanner.getToken() !== 17) {
+    handleError2(9, [], []);
+  }
+  return true;
+}
+
+// node_modules/.pnpm/jsonc-parser@3.3.1/node_modules/jsonc-parser/lib/esm/main.js
+var ScanError;
+(function(ScanError2) {
+  ScanError2[ScanError2["None"] = 0] = "None";
+  ScanError2[ScanError2["UnexpectedEndOfComment"] = 1] = "UnexpectedEndOfComment";
+  ScanError2[ScanError2["UnexpectedEndOfString"] = 2] = "UnexpectedEndOfString";
+  ScanError2[ScanError2["UnexpectedEndOfNumber"] = 3] = "UnexpectedEndOfNumber";
+  ScanError2[ScanError2["InvalidUnicode"] = 4] = "InvalidUnicode";
+  ScanError2[ScanError2["InvalidEscapeCharacter"] = 5] = "InvalidEscapeCharacter";
+  ScanError2[ScanError2["InvalidCharacter"] = 6] = "InvalidCharacter";
+})(ScanError || (ScanError = {}));
+var SyntaxKind;
+(function(SyntaxKind2) {
+  SyntaxKind2[SyntaxKind2["OpenBraceToken"] = 1] = "OpenBraceToken";
+  SyntaxKind2[SyntaxKind2["CloseBraceToken"] = 2] = "CloseBraceToken";
+  SyntaxKind2[SyntaxKind2["OpenBracketToken"] = 3] = "OpenBracketToken";
+  SyntaxKind2[SyntaxKind2["CloseBracketToken"] = 4] = "CloseBracketToken";
+  SyntaxKind2[SyntaxKind2["CommaToken"] = 5] = "CommaToken";
+  SyntaxKind2[SyntaxKind2["ColonToken"] = 6] = "ColonToken";
+  SyntaxKind2[SyntaxKind2["NullKeyword"] = 7] = "NullKeyword";
+  SyntaxKind2[SyntaxKind2["TrueKeyword"] = 8] = "TrueKeyword";
+  SyntaxKind2[SyntaxKind2["FalseKeyword"] = 9] = "FalseKeyword";
+  SyntaxKind2[SyntaxKind2["StringLiteral"] = 10] = "StringLiteral";
+  SyntaxKind2[SyntaxKind2["NumericLiteral"] = 11] = "NumericLiteral";
+  SyntaxKind2[SyntaxKind2["LineCommentTrivia"] = 12] = "LineCommentTrivia";
+  SyntaxKind2[SyntaxKind2["BlockCommentTrivia"] = 13] = "BlockCommentTrivia";
+  SyntaxKind2[SyntaxKind2["LineBreakTrivia"] = 14] = "LineBreakTrivia";
+  SyntaxKind2[SyntaxKind2["Trivia"] = 15] = "Trivia";
+  SyntaxKind2[SyntaxKind2["Unknown"] = 16] = "Unknown";
+  SyntaxKind2[SyntaxKind2["EOF"] = 17] = "EOF";
+})(SyntaxKind || (SyntaxKind = {}));
+var parse2 = parse;
+var ParseErrorCode;
+(function(ParseErrorCode2) {
+  ParseErrorCode2[ParseErrorCode2["InvalidSymbol"] = 1] = "InvalidSymbol";
+  ParseErrorCode2[ParseErrorCode2["InvalidNumberFormat"] = 2] = "InvalidNumberFormat";
+  ParseErrorCode2[ParseErrorCode2["PropertyNameExpected"] = 3] = "PropertyNameExpected";
+  ParseErrorCode2[ParseErrorCode2["ValueExpected"] = 4] = "ValueExpected";
+  ParseErrorCode2[ParseErrorCode2["ColonExpected"] = 5] = "ColonExpected";
+  ParseErrorCode2[ParseErrorCode2["CommaExpected"] = 6] = "CommaExpected";
+  ParseErrorCode2[ParseErrorCode2["CloseBraceExpected"] = 7] = "CloseBraceExpected";
+  ParseErrorCode2[ParseErrorCode2["CloseBracketExpected"] = 8] = "CloseBracketExpected";
+  ParseErrorCode2[ParseErrorCode2["EndOfFileExpected"] = 9] = "EndOfFileExpected";
+  ParseErrorCode2[ParseErrorCode2["InvalidCommentToken"] = 10] = "InvalidCommentToken";
+  ParseErrorCode2[ParseErrorCode2["UnexpectedEndOfComment"] = 11] = "UnexpectedEndOfComment";
+  ParseErrorCode2[ParseErrorCode2["UnexpectedEndOfString"] = 12] = "UnexpectedEndOfString";
+  ParseErrorCode2[ParseErrorCode2["UnexpectedEndOfNumber"] = 13] = "UnexpectedEndOfNumber";
+  ParseErrorCode2[ParseErrorCode2["InvalidUnicode"] = 14] = "InvalidUnicode";
+  ParseErrorCode2[ParseErrorCode2["InvalidEscapeCharacter"] = 15] = "InvalidEscapeCharacter";
+  ParseErrorCode2[ParseErrorCode2["InvalidCharacter"] = 16] = "InvalidCharacter";
+})(ParseErrorCode || (ParseErrorCode = {}));
+
+// src/validation/config/scope.ts
+import { existsSync, readdirSync, readFileSync } from "fs";
+import { join as join11 } from "path";
+var TSCONFIG_FILES = {
+  full: "tsconfig.json",
+  production: "tsconfig.production.json"
+};
+var defaultScopeDeps = {
+  readFileSync,
+  existsSync,
+  readdirSync
+};
+function parseTypeScriptConfig(configPath, deps = defaultScopeDeps) {
+  try {
+    const configContent = deps.readFileSync(configPath, "utf-8");
+    const parsed = parse2(configContent);
+    return parsed;
+  } catch {
+    return {
+      include: ["**/*.ts", "**/*.tsx"],
+      exclude: ["node_modules/**", ".pnpm-store/**", "dist/**"]
+    };
+  }
+}
+function resolveTypeScriptConfig(scope, deps = defaultScopeDeps) {
+  const configFile = TSCONFIG_FILES[scope];
+  const config = parseTypeScriptConfig(configFile, deps);
+  if (config.extends) {
+    const baseConfig = parseTypeScriptConfig(config.extends, deps);
+    return {
+      include: config.include ?? baseConfig.include ?? [],
+      exclude: [...baseConfig.exclude ?? [], ...config.exclude ?? []]
+    };
+  }
+  return {
+    include: config.include ?? [],
+    exclude: config.exclude ?? []
+  };
+}
+function hasTypeScriptFilesRecursive(dirPath, maxDepth = 2, deps = defaultScopeDeps) {
+  if (maxDepth <= 0) return false;
+  try {
+    const items = deps.readdirSync(dirPath, { withFileTypes: true });
+    const hasDirectTsFiles = items.some(
+      (item) => item.isFile() && (item.name.endsWith(".ts") || item.name.endsWith(".tsx"))
+    );
+    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)) {
+        return true;
+      }
+    }
+    return false;
+  } catch {
+    return false;
+  }
+}
+function getTopLevelDirectoriesWithTypeScript(config, deps = defaultScopeDeps) {
+  const allTopLevelItems = deps.readdirSync(".", { withFileTypes: true });
+  const directories = /* @__PURE__ */ new Set();
+  const topLevelDirs = allTopLevelItems.filter((item) => item.isDirectory()).map((item) => item.name).filter((name) => !name.startsWith("."));
+  for (const dir of topLevelDirs) {
+    const isExcluded = config.exclude?.some((pattern) => {
+      if (pattern.includes("/**")) {
+        const dirPattern = pattern.split("/**")[0];
+        return dirPattern === dir;
+      }
+      return pattern === dir || pattern.startsWith(dir + "/") || pattern === dir + "/**";
+    });
+    if (!isExcluded) {
+      try {
+        const hasTypeScriptFiles = hasTypeScriptFilesRecursive(dir, 2, deps);
+        if (hasTypeScriptFiles) {
+          directories.add(dir);
+        }
+      } catch {
+        continue;
+      }
+    }
+  }
+  if (config.include) {
+    for (const pattern of config.include) {
+      if (pattern.includes("/")) {
+        const topLevelDir = pattern.split("/")[0];
+        if (topLevelDir && !topLevelDir.includes("*") && !topLevelDir.startsWith(".")) {
+          directories.add(topLevelDir);
+        }
+      }
+    }
+  }
+  return Array.from(directories).sort();
+}
+function getValidationDirectories(scope, deps = defaultScopeDeps) {
+  const config = resolveTypeScriptConfig(scope, deps);
+  const configDirectories = getTopLevelDirectoriesWithTypeScript(config, deps);
+  const existingDirectories = configDirectories.filter((dir) => deps.existsSync(dir));
+  return existingDirectories;
+}
+function getTypeScriptScope(scope, deps = defaultScopeDeps) {
+  const directories = getValidationDirectories(scope, deps);
+  const config = resolveTypeScriptConfig(scope, deps);
+  return {
+    directories,
+    filePatterns: config.include ?? [],
+    excludePatterns: config.exclude ?? []
+  };
+}
+
+// src/validation/discovery/tool-finder.ts
+import { execSync } from "child_process";
+import fs6 from "fs";
+import { createRequire } from "module";
+import path7 from "path";
+
+// src/validation/discovery/constants.ts
+var TOOL_DISCOVERY = {
+  /** Tool source identifiers */
+  SOURCES: {
+    /** Tool bundled with spx-cli */
+    BUNDLED: "bundled",
+    /** Tool in project's node_modules */
+    PROJECT: "project",
+    /** Tool in system PATH */
+    GLOBAL: "global"
+  },
+  /** Message templates */
+  MESSAGES: {
+    /** Prefix for skip messages */
+    SKIP_PREFIX: "\u23ED",
+    // ⏭ emoji
+    /**
+     * Format not found reason message.
+     * @param tool - The tool name that was not found
+     */
+    NOT_FOUND_REASON: (tool) => `${tool} not found in bundled deps, project node_modules, or system PATH`,
+    /**
+     * Format skip message for graceful degradation.
+     * @param step - The validation step name
+     * @param tool - The tool that was not found
+     */
+    SKIP_FORMAT: (step, tool) => `${TOOL_DISCOVERY.MESSAGES.SKIP_PREFIX} Skipping ${step} (${tool} not available)`
+  }
+};
+
+// src/validation/discovery/tool-finder.ts
+var require2 = createRequire(import.meta.url);
+var defaultToolDiscoveryDeps = {
+  resolveModule: (modulePath) => {
+    try {
+      return require2.resolve(modulePath);
+    } catch {
+      return null;
+    }
+  },
+  existsSync: fs6.existsSync,
+  whichSync: (tool) => {
+    try {
+      const result = execSync(`which ${tool}`, {
+        encoding: "utf-8",
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+      return result.trim() || null;
+    } catch {
+      return null;
+    }
+  }
+};
+async function discoverTool(tool, options = {}) {
+  const { projectRoot = process.cwd(), deps = defaultToolDiscoveryDeps } = options;
+  const bundledPath = deps.resolveModule(`${tool}/package.json`);
+  if (bundledPath) {
+    return {
+      found: true,
+      location: {
+        tool,
+        path: path7.dirname(bundledPath),
+        source: TOOL_DISCOVERY.SOURCES.BUNDLED
+      }
+    };
+  }
+  const projectBinPath = path7.join(projectRoot, "node_modules", ".bin", tool);
+  if (deps.existsSync(projectBinPath)) {
+    return {
+      found: true,
+      location: {
+        tool,
+        path: projectBinPath,
+        source: TOOL_DISCOVERY.SOURCES.PROJECT
+      }
+    };
+  }
+  const globalPath = deps.whichSync(tool);
+  if (globalPath) {
+    return {
+      found: true,
+      location: {
+        tool,
+        path: globalPath,
+        source: TOOL_DISCOVERY.SOURCES.GLOBAL
+      }
+    };
+  }
+  return {
+    found: false,
+    notFound: {
+      tool,
+      reason: TOOL_DISCOVERY.MESSAGES.NOT_FOUND_REASON(tool)
+    }
+  };
+}
+function formatSkipMessage(stepName, result) {
+  if (result.found) {
+    return "";
+  }
+  return TOOL_DISCOVERY.MESSAGES.SKIP_FORMAT(stepName, result.notFound.tool);
+}
+
+// src/validation/steps/circular.ts
+import madge from "madge";
+
+// src/validation/steps/constants.ts
+var STEP_IDS = {
+  CIRCULAR: "circular-deps",
+  ESLINT: "eslint",
+  TYPESCRIPT: "typescript",
+  KNIP: "knip"
+};
+var STEP_NAMES = {
+  CIRCULAR: "Circular Dependencies",
+  ESLINT: "ESLint",
+  TYPESCRIPT: "TypeScript",
+  KNIP: "Unused Code"
+};
+var STEP_DESCRIPTIONS = {
+  CIRCULAR: "Checking for circular dependencies",
+  ESLINT: "Validating ESLint compliance",
+  TYPESCRIPT: "Validating TypeScript",
+  KNIP: "Detecting unused exports, dependencies, and files"
+};
+var CACHE_PATHS = {
+  ESLINT: "dist/.eslintcache",
+  TIMINGS: "dist/.validation-timings.json"
+};
+var VALIDATION_KEYS = {
+  TYPESCRIPT: "TYPESCRIPT",
+  ESLINT: "ESLINT",
+  KNIP: "KNIP"
+};
+var VALIDATION_DEFAULTS = {
+  [VALIDATION_KEYS.TYPESCRIPT]: true,
+  [VALIDATION_KEYS.ESLINT]: true,
+  [VALIDATION_KEYS.KNIP]: false
+};
+
+// src/validation/steps/circular.ts
+var defaultCircularDeps = {
+  madge
+};
+async function validateCircularDependencies(scope, typescriptScope, deps = defaultCircularDeps) {
+  try {
+    const analyzeDirectories = typescriptScope.directories;
+    if (analyzeDirectories.length === 0) {
+      return { success: true };
+    }
+    const tsConfigFile = TSCONFIG_FILES[scope];
+    const excludeRegExps = typescriptScope.excludePatterns.map((pattern) => {
+      const cleanPattern = pattern.replace(/\/\*\*?\/\*$/, "");
+      const escaped = cleanPattern.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+      return new RegExp(escaped);
+    });
+    const result = await deps.madge(analyzeDirectories, {
+      fileExtensions: ["ts", "tsx"],
+      tsConfig: tsConfigFile,
+      excludeRegExp: excludeRegExps
+    });
+    const circular = result.circular();
+    if (circular.length === 0) {
+      return { success: true };
+    } else {
+      return {
+        success: false,
+        error: `Found ${circular.length} circular dependency cycle(s)`,
+        circularDependencies: circular
+      };
+    }
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    return { success: false, error: errorMessage };
+  }
+}
+var circularDependencyStep = {
+  id: STEP_IDS.CIRCULAR,
+  name: STEP_NAMES.CIRCULAR,
+  description: STEP_DESCRIPTIONS.CIRCULAR,
+  enabled: (context) => !context.isFileSpecificMode && context.enabledValidations[VALIDATION_KEYS.TYPESCRIPT] === true,
+  execute: async (context) => {
+    const startTime = performance.now();
+    try {
+      const result = await validateCircularDependencies(context.scope, context.scopeConfig);
+      return {
+        success: result.success,
+        error: result.error,
+        duration: performance.now() - startTime
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : String(error),
+        duration: performance.now() - startTime
+      };
+    }
+  }
+};
+
+// src/commands/validation/circular.ts
+async function circularCommand(options) {
+  const { cwd, quiet } = options;
+  const startTime = Date.now();
+  const toolResult = await discoverTool("madge", { projectRoot: cwd });
+  if (!toolResult.found) {
+    const skipMessage = formatSkipMessage("circular dependency check", toolResult);
+    return { exitCode: 0, output: skipMessage, durationMs: Date.now() - startTime };
+  }
+  const scopeConfig = getTypeScriptScope("full");
+  const result = await validateCircularDependencies("full", scopeConfig);
+  const durationMs = Date.now() - startTime;
+  if (result.success) {
+    const output = quiet ? "" : `Circular dependencies: \u2713 None found`;
+    return { exitCode: 0, output, durationMs };
+  } else {
+    let output = result.error ?? "Circular dependencies found";
+    if (result.circularDependencies && result.circularDependencies.length > 0) {
+      const cycles = result.circularDependencies.map((cycle) => `  ${cycle.join(" \u2192 ")}`).join("\n");
+      output = `Circular dependencies found:
+${cycles}`;
+    }
+    return { exitCode: 1, output, durationMs };
+  }
+}
+
+// src/commands/validation/format.ts
+var DURATION_THRESHOLD_MS = 1e3;
+var VALIDATION_SYMBOLS = {
+  SUCCESS: "\u2713",
+  FAILURE: "\u2717"
+};
+function formatDuration(ms) {
+  if (ms < DURATION_THRESHOLD_MS) {
+    return `${ms}ms`;
+  }
+  const seconds = ms / 1e3;
+  return `${seconds.toFixed(1)}s`;
+}
+function formatSummary(options) {
+  const { success, totalDurationMs } = options;
+  const symbol = success ? VALIDATION_SYMBOLS.SUCCESS : VALIDATION_SYMBOLS.FAILURE;
+  const status = success ? "passed" : "failed";
+  const duration = formatDuration(totalDurationMs);
+  return `${symbol} Validation ${status} (${duration} total)`;
+}
+
+// src/validation/steps/eslint.ts
+import { spawn } from "child_process";
+
+// src/validation/types.ts
+var VALIDATION_SCOPES = {
+  /** Validate entire codebase including tests and scripts */
+  FULL: "full",
+  /** Validate production files only */
+  PRODUCTION: "production"
+};
+var EXECUTION_MODES = {
+  /** Read-only mode - report errors without fixing */
+  READ: "read",
+  /** Write mode - fix errors when possible (e.g., eslint --fix) */
+  WRITE: "write"
+};
+
+// src/validation/steps/eslint.ts
+var defaultEslintProcessRunner = { spawn };
+function buildEslintArgs(context) {
+  const { validatedFiles, mode, cacheFile } = context;
+  const fixArg = mode === EXECUTION_MODES.WRITE ? ["--fix"] : [];
+  const cacheArgs = ["--cache", "--cache-location", cacheFile];
+  if (validatedFiles && validatedFiles.length > 0) {
+    return ["eslint", "--config", "eslint.config.ts", ...cacheArgs, ...fixArg, "--", ...validatedFiles];
+  }
+  return ["eslint", ".", "--config", "eslint.config.ts", ...cacheArgs, ...fixArg];
+}
+async function validateESLint(context, runner = defaultEslintProcessRunner) {
+  const { scope, validatedFiles, mode } = context;
+  return new Promise((resolve2) => {
+    if (!validatedFiles || validatedFiles.length === 0) {
+      if (scope === VALIDATION_SCOPES.PRODUCTION) {
+        process.env.ESLINT_PRODUCTION_ONLY = "1";
+      } else {
+        delete process.env.ESLINT_PRODUCTION_ONLY;
+      }
+    }
+    const eslintArgs = buildEslintArgs({
+      validatedFiles,
+      mode,
+      cacheFile: CACHE_PATHS.ESLINT
+    });
+    const eslintProcess = runner.spawn("npx", eslintArgs, {
+      cwd: process.cwd(),
+      stdio: "inherit"
+    });
+    eslintProcess.on("close", (code) => {
+      if (code === 0) {
+        resolve2({ success: true });
+      } else {
+        resolve2({ success: false, error: `ESLint exited with code ${code}` });
+      }
+    });
+    eslintProcess.on("error", (error) => {
+      resolve2({ success: false, error: error.message });
+    });
+  });
+}
+function validationEnabled(envVarKey, defaults = {}) {
+  const envVar = `${envVarKey}_VALIDATION_ENABLED`;
+  const explicitlyDisabled = process.env[envVar] === "0";
+  const explicitlyEnabled = process.env[envVar] === "1";
+  const defaultValue = defaults[envVarKey] ?? true;
+  if (defaultValue) {
+    return !explicitlyDisabled;
+  }
+  return explicitlyEnabled;
+}
+var eslintStep = {
+  id: STEP_IDS.ESLINT,
+  name: STEP_NAMES.ESLINT,
+  description: STEP_DESCRIPTIONS.ESLINT,
+  enabled: (context) => context.enabledValidations[VALIDATION_KEYS.ESLINT] === true && validationEnabled(VALIDATION_KEYS.ESLINT),
+  execute: async (context) => {
+    const startTime = performance.now();
+    try {
+      const result = await validateESLint(context);
+      return {
+        success: result.success,
+        error: result.error,
+        duration: performance.now() - startTime
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : String(error),
+        duration: performance.now() - startTime
+      };
+    }
+  }
+};
+
+// src/validation/steps/knip.ts
+import { spawn as spawn2 } from "child_process";
+var defaultKnipProcessRunner = { spawn: spawn2 };
+async function validateKnip(typescriptScope, runner = defaultKnipProcessRunner) {
+  try {
+    const analyzeDirectories = typescriptScope.directories;
+    if (analyzeDirectories.length === 0) {
+      return { success: true };
+    }
+    return new Promise((resolve2) => {
+      const knipProcess = runner.spawn("npx", ["knip"], {
+        cwd: process.cwd(),
+        stdio: "pipe"
+      });
+      let knipOutput = "";
+      let knipError = "";
+      knipProcess.stdout?.on("data", (data) => {
+        knipOutput += data.toString();
+      });
+      knipProcess.stderr?.on("data", (data) => {
+        knipError += data.toString();
+      });
+      knipProcess.on("close", (code) => {
+        if (code === 0) {
+          resolve2({ success: true });
+        } else {
+          const errorOutput = knipOutput || knipError || "Unused code detected";
+          resolve2({
+            success: false,
+            error: errorOutput
+          });
+        }
+      });
+      knipProcess.on("error", (error) => {
+        resolve2({ success: false, error: error.message });
+      });
+    });
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    return { success: false, error: errorMessage };
+  }
+}
+var knipStep = {
+  id: STEP_IDS.KNIP,
+  name: STEP_NAMES.KNIP,
+  description: STEP_DESCRIPTIONS.KNIP,
+  enabled: (context) => context.enabledValidations[VALIDATION_KEYS.KNIP] === true && validationEnabled(VALIDATION_KEYS.KNIP, VALIDATION_DEFAULTS) && !context.isFileSpecificMode,
+  execute: async (context) => {
+    const startTime = performance.now();
+    try {
+      const result = await validateKnip(context.scopeConfig);
+      return {
+        success: result.success,
+        error: result.error,
+        duration: performance.now() - startTime
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : String(error),
+        duration: performance.now() - startTime
+      };
+    }
+  }
+};
+
+// src/commands/validation/knip.ts
+async function knipCommand(options) {
+  const { cwd, quiet } = options;
+  const startTime = Date.now();
+  if (!validationEnabled("KNIP", { KNIP: false })) {
+    const output = quiet ? "" : "Knip: skipped (disabled by default, set KNIP_VALIDATION_ENABLED=1 to enable)";
+    return { exitCode: 0, output, durationMs: Date.now() - startTime };
+  }
+  const toolResult = await discoverTool("knip", { projectRoot: cwd });
+  if (!toolResult.found) {
+    const skipMessage = formatSkipMessage("unused code detection", toolResult);
+    return { exitCode: 0, output: skipMessage, durationMs: Date.now() - startTime };
+  }
+  const scopeConfig = getTypeScriptScope("full");
+  const result = await validateKnip(scopeConfig);
+  const durationMs = Date.now() - startTime;
+  if (result.success) {
+    const output = quiet ? "" : `Knip: \u2713 No unused code found`;
+    return { exitCode: 0, output, durationMs };
+  } else {
+    const output = result.error ?? "Unused code found";
+    return { exitCode: 1, output, durationMs };
+  }
+}
+
+// src/commands/validation/lint.ts
+async function lintCommand(options) {
+  const { cwd, scope = "full", files, fix, quiet } = options;
+  const startTime = Date.now();
+  const toolResult = await discoverTool("eslint", { projectRoot: cwd });
+  if (!toolResult.found) {
+    const skipMessage = formatSkipMessage("ESLint", toolResult);
+    return { exitCode: 0, output: skipMessage, durationMs: Date.now() - startTime };
+  }
+  const scopeConfig = getTypeScriptScope(scope);
+  const context = {
+    projectRoot: cwd,
+    scope,
+    scopeConfig,
+    mode: fix ? "write" : "read",
+    enabledValidations: { ESLINT: true },
+    validatedFiles: files,
+    isFileSpecificMode: Boolean(files && files.length > 0)
+  };
+  const result = await validateESLint(context);
+  const durationMs = Date.now() - startTime;
+  if (result.success) {
+    const output = quiet ? "" : `ESLint: \u2713 No issues found`;
+    return { exitCode: 0, output, durationMs };
+  } else {
+    const output = result.error ?? "ESLint validation failed";
+    return { exitCode: 1, output, durationMs };
+  }
+}
+
+// src/validation/steps/typescript.ts
+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";
+var defaultTypeScriptProcessRunner = { spawn: spawn3 };
+var defaultTypeScriptDeps = {
+  mkdtemp,
+  writeFileSync,
+  rmSync,
+  existsSync: existsSync2,
+  mkdirSync
+};
+function buildTypeScriptArgs(context) {
+  const { scope, configFile } = 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 baseConfigFile = TSCONFIG_FILES[scope];
+  const projectRoot = process.cwd();
+  const absoluteFiles = files.map((file) => isAbsolute(file) ? file : join12(projectRoot, file));
+  const tempConfig = {
+    extends: join12(projectRoot, baseConfigFile),
+    files: absoluteFiles,
+    include: [],
+    exclude: [],
+    compilerOptions: {
+      noEmit: true,
+      typeRoots: [join12(projectRoot, "node_modules", "@types")],
+      types: ["node"]
+    }
+  };
+  deps.writeFileSync(configPath, JSON.stringify(tempConfig, null, 2));
+  const cleanup = () => {
+    try {
+      deps.rmSync(tempDir, { recursive: true, force: true });
+    } catch {
+    }
+  };
+  return { configPath, tempDir, cleanup };
+}
+async function validateTypeScript(scope, typescriptScope, files, runner = defaultTypeScriptProcessRunner, deps = defaultTypeScriptDeps) {
+  const configFile = TSCONFIG_FILES[scope];
+  let tool;
+  let tscArgs;
+  if (files && files.length > 0) {
+    const { configPath, cleanup } = await createFileSpecificTsconfig(scope, files, deps);
+    try {
+      return await new Promise((resolve2) => {
+        const tscProcess = runner.spawn("npx", ["tsc", "--project", configPath], {
+          cwd: process.cwd(),
+          stdio: "inherit"
+        });
+        tscProcess.on("close", (code) => {
+          cleanup();
+          if (code === 0) {
+            resolve2({ success: true, skipped: false });
+          } else {
+            resolve2({ success: false, error: `TypeScript exited with code ${code}` });
+          }
+        });
+        tscProcess.on("error", (error) => {
+          cleanup();
+          resolve2({ success: false, error: error.message });
+        });
+      });
+    } catch (error) {
+      cleanup();
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      return { success: false, error: `Failed to create temporary config: ${errorMessage}` };
+    }
+  } else {
+    tool = "npx";
+    tscArgs = buildTypeScriptArgs({ scope, configFile });
+  }
+  return new Promise((resolve2) => {
+    const tscProcess = runner.spawn(tool, tscArgs, {
+      cwd: process.cwd(),
+      stdio: "inherit"
+    });
+    tscProcess.on("close", (code) => {
+      if (code === 0) {
+        resolve2({ success: true, skipped: false });
+      } else {
+        resolve2({ success: false, error: `TypeScript exited with code ${code}` });
+      }
+    });
+    tscProcess.on("error", (error) => {
+      resolve2({ success: false, error: error.message });
+    });
+  });
+}
+var typescriptStep = {
+  id: STEP_IDS.TYPESCRIPT,
+  name: STEP_NAMES.TYPESCRIPT,
+  description: STEP_DESCRIPTIONS.TYPESCRIPT,
+  enabled: (context) => context.enabledValidations[VALIDATION_KEYS.TYPESCRIPT] === true && validationEnabled(VALIDATION_KEYS.TYPESCRIPT),
+  execute: async (context) => {
+    const startTime = performance.now();
+    try {
+      const result = await validateTypeScript(
+        context.scope,
+        context.scopeConfig,
+        context.validatedFiles
+      );
+      return {
+        success: result.success,
+        error: result.error,
+        duration: performance.now() - startTime,
+        skipped: result.skipped
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : String(error),
+        duration: performance.now() - startTime
+      };
+    }
+  }
+};
+
+// src/commands/validation/typescript.ts
+async function typescriptCommand(options) {
+  const { cwd, scope = "full", files, quiet } = options;
+  const startTime = Date.now();
+  const toolResult = await discoverTool("typescript", { projectRoot: cwd });
+  if (!toolResult.found) {
+    const skipMessage = formatSkipMessage("TypeScript", toolResult);
+    return { exitCode: 0, output: skipMessage, durationMs: Date.now() - startTime };
+  }
+  const scopeConfig = getTypeScriptScope(scope);
+  const result = await validateTypeScript(scope, scopeConfig, files);
+  const durationMs = Date.now() - startTime;
+  if (result.success) {
+    const output = quiet ? "" : `TypeScript: \u2713 No type errors`;
+    return { exitCode: 0, output, durationMs };
+  } else {
+    const output = result.error ?? "TypeScript validation failed";
+    return { exitCode: 1, output, durationMs };
+  }
+}
+
+// src/commands/validation/all.ts
+var TOTAL_STEPS = 4;
+function formatStepWithTiming(stepNumber, result, quiet) {
+  if (quiet || !result.output) return "";
+  const timing = result.durationMs === void 0 ? "" : ` (${formatDuration(result.durationMs)})`;
+  return `[${stepNumber}/${TOTAL_STEPS}] ${result.output}${timing}`;
+}
+async function allCommand(options) {
+  const { cwd, scope, files, fix, quiet = false, json } = options;
+  const startTime = Date.now();
+  const outputs = [];
+  let hasFailure = false;
+  const circularResult = await circularCommand({ cwd, quiet, json });
+  const circularOutput = formatStepWithTiming(1, circularResult, quiet);
+  if (circularOutput) outputs.push(circularOutput);
+  if (circularResult.exitCode !== 0) hasFailure = true;
+  const knipResult = await knipCommand({ cwd, quiet, json });
+  const knipOutput = formatStepWithTiming(2, knipResult, quiet);
+  if (knipOutput) outputs.push(knipOutput);
+  const lintResult = await lintCommand({ cwd, scope, files, fix, quiet, json });
+  const lintOutput = formatStepWithTiming(3, lintResult, quiet);
+  if (lintOutput) outputs.push(lintOutput);
+  if (lintResult.exitCode !== 0) hasFailure = true;
+  const tsResult = await typescriptCommand({ cwd, scope, files, quiet, json });
+  const tsOutput = formatStepWithTiming(4, tsResult, quiet);
+  if (tsOutput) outputs.push(tsOutput);
+  if (tsResult.exitCode !== 0) hasFailure = true;
+  const totalDurationMs = Date.now() - startTime;
+  if (!quiet) {
+    const summary = formatSummary({ success: !hasFailure, totalDurationMs });
+    outputs.push("", summary);
+  }
+  return {
+    exitCode: hasFailure ? 1 : 0,
+    output: outputs.join("\n"),
+    durationMs: totalDurationMs
+  };
+}
+
+// src/domains/validation/index.ts
+function addCommonOptions(cmd) {
+  return cmd.option("--scope <scope>", "Validation scope (full|production)", "full").option("--files <paths...>", "Specific files/directories to validate").option("--quiet", "Suppress progress output").option("--json", "Output results as JSON");
+}
+function registerValidationCommands(validationCmd) {
+  const tsCmd = validationCmd.command("typescript").alias("ts").description("Run TypeScript type checking").action(async (options) => {
+    const result = await typescriptCommand({
+      cwd: process.cwd(),
+      scope: options.scope,
+      files: options.files,
+      quiet: options.quiet,
+      json: options.json
+    });
+    if (result.output) console.log(result.output);
+    process.exit(result.exitCode);
+  });
+  addCommonOptions(tsCmd);
+  const lintCmd = validationCmd.command("lint").description("Run ESLint").option("--fix", "Auto-fix issues").action(async (options) => {
+    const result = await lintCommand({
+      cwd: process.cwd(),
+      scope: options.scope,
+      files: options.files,
+      fix: options.fix,
+      quiet: options.quiet,
+      json: options.json
+    });
+    if (result.output) console.log(result.output);
+    process.exit(result.exitCode);
+  });
+  addCommonOptions(lintCmd);
+  const circularCmd = validationCmd.command("circular").description("Check for circular dependencies").action(async (options) => {
+    const result = await circularCommand({
+      cwd: process.cwd(),
+      quiet: options.quiet,
+      json: options.json
+    });
+    if (result.output) console.log(result.output);
+    process.exit(result.exitCode);
+  });
+  addCommonOptions(circularCmd);
+  const knipCmd = validationCmd.command("knip").description("Detect unused code").action(async (options) => {
+    const result = await knipCommand({
+      cwd: process.cwd(),
+      quiet: options.quiet,
+      json: options.json
+    });
+    if (result.output) console.log(result.output);
+    process.exit(result.exitCode);
+  });
+  addCommonOptions(knipCmd);
+  const allCmd = validationCmd.command("all", { isDefault: true }).description("Run all validations").option("--fix", "Auto-fix ESLint issues").action(async (options) => {
+    const result = await allCommand({
+      cwd: process.cwd(),
+      scope: options.scope,
+      files: options.files,
+      fix: options.fix,
+      quiet: options.quiet,
+      json: options.json
+    });
+    if (result.output) console.log(result.output);
+    process.exit(result.exitCode);
+  });
+  addCommonOptions(allCmd);
+}
+var validationDomain = {
+  name: "validation",
+  description: "Run code validation tools",
+  register: (program2) => {
+    const validationCmd = program2.command("validation").alias("v").description("Run code validation tools");
+    registerValidationCommands(validationCmd);
+  }
+};
+
+// src/cli.ts
+var program = new Command();
+program.name("spx").description("Fast, deterministic CLI tool for spec workflow management").version("0.2.0");
+claudeDomain.register(program);
+sessionDomain.register(program);
+specDomain.register(program);
+validationDomain.register(program);
+program.parse();
+//# sourceMappingURL=cli.js.map