@outcomeeng/spx 0.6.4 → 0.6.6

package/dist/cli.js

@@ -4036,7 +4036,14 @@ function sessionStoreRunner(probe) {
 // src/domains/hooks/session-start.ts
 var HOOK_SESSION_START_PAYLOAD = {
   CWD: "cwd",
-  SESSION_ID: "session_id"
+  SESSION_ID: "session_id",
+  SOURCE: "source"
+};
+var HOOK_SESSION_START_SOURCE = {
+  CLEAR: "clear",
+  COMPACT: "compact",
+  RESUME: "resume",
+  STARTUP: "startup"
 };
 var HOOK_SESSION_START_ENV = {
   CLAUDE_ENV_FILE: "CLAUDE_ENV_FILE",
@@ -4080,7 +4087,8 @@ function parseHookSessionStartPayload(content) {
     ok: true,
     value: {
       cwd: nonEmptyString(record6[HOOK_SESSION_START_PAYLOAD.CWD]),
-      sessionId: nonEmptyString(record6[HOOK_SESSION_START_PAYLOAD.SESSION_ID])
+      sessionId: nonEmptyString(record6[HOOK_SESSION_START_PAYLOAD.SESSION_ID]),
+      source: nonEmptyString(record6[HOOK_SESSION_START_PAYLOAD.SOURCE])
     }
   };
 }
@@ -4090,6 +4098,15 @@ function resolveHookSessionStartSessionId(payload, env) {
 function resolveHookSessionStartProductDir(payload, cwd) {
   return payload.cwd ?? cwd;
 }
+var NO_STARTUP_DIRECTIVE = "";
+var HOOK_COMPACT_FOUNDATION_DIRECTIVE = [
+  "Spec-tree foundation was reset by this compaction.",
+  "Before any spec-governed action, including resuming an in-flight PR, /apply, or /handoff, re-invoke /understand then /contextualize on every spec node still in scope (not just the next one) before any gh/git archaeology or reading spec-governed source.",
+  "The pre-compaction skill text in this summary is a historical record, not a live tool."
+].join("\n");
+function renderSessionStartStdout(source) {
+  return source === HOOK_SESSION_START_SOURCE.COMPACT ? HOOK_COMPACT_FOUNDATION_DIRECTIVE : NO_STARTUP_DIRECTIVE;
+}
 function resolveHookSessionStartEnvFile(env, explicitEnvFile) {
   return nonEmptyString(explicitEnvFile) ?? nonEmptyString(env[HOOK_SESSION_START_ENV.CLAUDE_ENV_FILE]);
 }
@@ -4954,7 +4971,8 @@ function isValidPid(pid) {
 // src/domains/worktree/resolve.ts
 import { dirname as dirname4, resolve as resolve4 } from "path";
 var WORKTREE_RESOLVE_ERROR = {
-  NOT_A_WORKTREE: "path resolves to no worktree"
+  NOT_A_WORKTREE: "path resolves to no worktree",
+  WORKTREE_LIST_UNAVAILABLE: "git worktree list is unavailable"
 };
 async function resolveWorktreesDir(options) {
   if (options.worktreesDir !== void 0) return options.worktreesDir;
@@ -4966,6 +4984,22 @@ async function resolveCurrentWorktreeName(options) {
   const worktree = await detectWorktreeProductRoot(options.cwd, options.gitDeps);
   return worktreeClaimName(worktree.productDir);
 }
+async function resolveAllTargetWorktrees(options) {
+  const facts = await gatherGitFacts(options.cwd, options.gitDeps);
+  if (facts === null) {
+    return { ok: false, error: `${WORKTREE_RESOLVE_ERROR.NOT_A_WORKTREE}: ${options.cwd}` };
+  }
+  if (!facts.worktreeListRead) {
+    return { ok: false, error: WORKTREE_RESOLVE_ERROR.WORKTREE_LIST_UNAVAILABLE };
+  }
+  return {
+    ok: true,
+    value: facts.worktreeRoots.map((worktreeRoot) => ({
+      name: worktreeClaimName(worktreeRoot),
+      worktreeRoot
+    }))
+  };
+}
 async function resolveTargetWorktree(options) {
   const base = options.cwd;
   const targetPath = options.worktree === void 0 ? base : resolve4(base, options.worktree);
@@ -5003,7 +5037,6 @@ var defaultHookEnvFileSystem = {
   }
 };
 var ERROR_DETAIL_SEPARATOR3 = ": ";
-var EMPTY_HOOK_STDOUT = "";
 async function runSessionStartHook(options) {
   const diagnostics = [];
   const payloadResult = parseHookSessionStartPayload(options.content);
@@ -5042,7 +5075,7 @@ async function runSessionStartHook(options) {
       diagnostics,
       envFileWritten,
       productDir,
-      stdout: EMPTY_HOOK_STDOUT,
+      stdout: renderSessionStartStdout(payload.source),
       ...sessionId === void 0 ? {} : { sessionId }
     }
   };
@@ -5135,17 +5168,17 @@ function createProcessHookIo(streams) {
   return {
     readStdin: async () => {
       if (streams.stdin.isTTY) return { ok: true, value: void 0 };
-      return new Promise((resolve10) => {
+      return new Promise((resolve11) => {
         let data = "";
         streams.stdin.setEncoding("utf-8");
         streams.stdin.on(HOOK_PROCESS_IO_EVENT.DATA, (chunk) => {
           data += chunk;
         });
         streams.stdin.on(HOOK_PROCESS_IO_EVENT.END, () => {
-          resolve10({ ok: true, value: data.length === 0 ? void 0 : data });
+          resolve11({ ok: true, value: data.length === 0 ? void 0 : data });
         });
         streams.stdin.on(HOOK_PROCESS_IO_EVENT.ERROR, (error) => {
-          resolve10({ ok: false, error: formatStdinReadError(error) });
+          resolve11({ ok: false, error: formatStdinReadError(error) });
         });
       });
     },
@@ -6255,16 +6288,16 @@ ${output}`;
 // src/domains/session/handoff-base-checklist.ts
 var SESSION_HANDOFF_BASE_ERROR_NAME = "SessionHandoffBaseError";
 var HANDOFF_BASE_MARK = {
-  MET: "\u2713",
-  UNMET: "\u2717"
+  MET: "[PASS]:",
+  UNMET: "[FAIL]:"
 };
 var HANDOFF_BASE_PREREQUISITE_LABEL = {
   CLEAN_WORKING_TREE: "working tree is clean",
   DETACHED_AT_DEFAULT_TIP: "HEAD is detached at the default-branch tip"
 };
 var HANDOFF_BASE_REMEDY = {
-  /** Unclean working tree: commit, or hand off from the main checkout. */
-  COMMIT_OR_MAIN_CHECKOUT: "commit the changes, or run handoff from the main checkout",
+  /** Unclean working tree: commit before any handoff proceeds. */
+  COMMIT_BEFORE_HANDOFF: "commit the changes before handoff. DO NOT PROCEED while this checkout is dirty",
   /** Off the default-branch tip: detach to it, or hand off from the main checkout. */
   DETACH_TO_TIP_OR_MAIN_CHECKOUT: "detach HEAD to the default-branch tip, or run handoff from the main checkout",
   /** Default branch unresolved: only the main checkout can anchor the base. */
@@ -6281,23 +6314,34 @@ var HANDOFF_BASE_UNRESOLVED = "unresolved";
 var CHECKLIST_INDENT = "  ";
 var REMEDY_SEPARATOR = " \u2014 ";
 var CHECKLIST_HEADER = `${SESSION_HANDOFF_BASE_ERROR_NAME}: cannot create a handoff session from this worktree \u2014 it is not the main checkout.`;
+var HANDOFF_BASE_DIRTY_HEADER = `${SESSION_HANDOFF_BASE_ERROR_NAME}: YOUR CHECKOUT IS DIRTY. YOU CANNOT HANDOFF.`;
+var HANDOFF_BASE_FACTS_HEADER = "GIT FACTS:";
+var HANDOFF_BASE_CHECKS_HEADER = "HERE ARE THE CHECKS AND THEIR STATUS:";
 function renderFactLine(label, value) {
   return `${CHECKLIST_INDENT}${label}: ${value ?? HANDOFF_BASE_UNRESOLVED}`;
 }
-function renderPrerequisiteLine(prerequisite) {
+function renderPrerequisiteLine(prerequisite, index) {
   const mark = prerequisite.met ? HANDOFF_BASE_MARK.MET : HANDOFF_BASE_MARK.UNMET;
-  const base = `${CHECKLIST_INDENT}${mark} ${prerequisite.label}`;
+  const lineNumber = index + 1;
+  const base = `${lineNumber}. ${mark} ${prerequisite.label}`;
   return prerequisite.met ? base : `${base}${REMEDY_SEPARATOR}${prerequisite.remedy}`;
 }
+function isDirtyCheckoutRefusal(checklist) {
+  return checklist.prerequisites.some(
+    (prerequisite) => prerequisite.label === HANDOFF_BASE_PREREQUISITE_LABEL.CLEAN_WORKING_TREE && !prerequisite.met
+  );
+}
 function renderHandoffBaseChecklist(checklist) {
   return [
-    CHECKLIST_HEADER,
+    isDirtyCheckoutRefusal(checklist) ? HANDOFF_BASE_DIRTY_HEADER : CHECKLIST_HEADER,
+    HANDOFF_BASE_FACTS_HEADER,
     renderFactLine(HANDOFF_BASE_FACT_LABEL.DEFAULT_BRANCH, checklist.defaultBranch),
     renderFactLine(HANDOFF_BASE_FACT_LABEL.DEFAULT_TIP, checklist.defaultTipSha),
     renderFactLine(HANDOFF_BASE_FACT_LABEL.HEAD, checklist.headSha),
     renderFactLine(HANDOFF_BASE_FACT_LABEL.CURRENT_WORKTREE, checklist.currentWorktreePath),
     renderFactLine(HANDOFF_BASE_FACT_LABEL.MAIN_CHECKOUT, checklist.mainCheckoutPath),
-    ...checklist.prerequisites.map(renderPrerequisiteLine)
+    HANDOFF_BASE_CHECKS_HEADER,
+    ...checklist.prerequisites.map((prerequisite, index) => renderPrerequisiteLine(prerequisite, index))
   ].join("\n");
 }
 
@@ -6404,6 +6448,17 @@ var SessionWorkBranchNotOnOriginError = class extends SessionError {
     this.workBranch = workBranch;
   }
 };
+var SessionInjectionDirectoryError = class extends SessionError {
+  /** The listed `specs`/`files` entry that resolves to an existing directory. */
+  entry;
+  constructor(entry) {
+    super(
+      `Session injection entry resolves to a directory: ${entry}. The specs and files arrays hold file paths; list the file inside the directory rather than the directory itself.`
+    );
+    this.name = "SessionInjectionDirectoryError";
+    this.entry = entry;
+  }
+};
 var SessionInvalidJsonHeaderError = class extends SessionError {
   constructor(reason) {
     super(`Invalid JSON header for handoff: ${reason}`);
@@ -6985,7 +7040,7 @@ async function deleteCommand(options) {
 }
 
 // src/commands/session/handoff.ts
-import { mkdir as mkdir2, writeFile } from "fs/promises";
+import { mkdir as mkdir2, stat as stat3, writeFile } from "fs/promises";
 import { join as join11, resolve as resolve5 } from "path";
 import { stringify as stringifyYaml3 } from "yaml";
 
@@ -7007,7 +7062,7 @@ function cleanPrerequisite(facts) {
   return {
     label: HANDOFF_BASE_PREREQUISITE_LABEL.CLEAN_WORKING_TREE,
     met: facts.isClean,
-    remedy: facts.isClean ? "" : HANDOFF_BASE_REMEDY.COMMIT_OR_MAIN_CHECKOUT
+    remedy: facts.isClean ? "" : HANDOFF_BASE_REMEDY.COMMIT_BEFORE_HANDOFF
   };
 }
 function detachedAtTipPrerequisite(facts, met) {
@@ -7231,6 +7286,20 @@ async function resolveRecordedGitRef(suppliedRef, gateRef, cwd, deps) {
   const existsOnOrigin = await originBranchExists(suppliedRef, cwd, deps);
   return resolveWorkBranchGitRef(suppliedRef, existsOnOrigin);
 }
+async function rejectDirectoryInjectionEntries(entries, cwd) {
+  for (const entry of entries) {
+    if (entry.length === 0) continue;
+    let entryIsDirectory = false;
+    try {
+      entryIsDirectory = (await stat3(resolve5(cwd, entry))).isDirectory();
+    } catch {
+      continue;
+    }
+    if (entryIsDirectory) {
+      throw new SessionInjectionDirectoryError(entry);
+    }
+  }
+}
 async function handoffCommand(options) {
   const { config } = await resolveSessionConfig({
     sessionsDir: options.sessionsDir,
@@ -7250,6 +7319,8 @@ async function handoffCommand(options) {
   }
   const gateRef = await resolveSessionGitRef(options.cwd, options.deps);
   const gitRef = await resolveRecordedGitRef(header.git_ref, gateRef, options.cwd, options.deps);
+  const injectionCwd = options.cwd ?? CONFIG_PROCESS_CWD.read();
+  await rejectDirectoryInjectionEntries([...header.specs, ...header.files], injectionCwd);
   const sessionId = generateSessionId();
   const agentSessionId = resolveAgentSessionId(options.env ?? process.env);
   const createdAt = (/* @__PURE__ */ new Date()).toISOString();
@@ -7430,6 +7501,7 @@ async function loadTodoSessionsWithDeps(config, deps) {
 }
 var SESSION_INJECTION_SECTION_PREFIX = "Injected file";
 var SESSION_INJECTION_MISSING_WARNING_PREFIX = "Warning: missing session injection file";
+var SESSION_INJECTION_UNREADABLE_WARNING_PREFIX = "Warning: unreadable session injection path";
 function injectionPath(cwd, filePath) {
   return resolve6(cwd, filePath);
 }
@@ -7437,6 +7509,11 @@ function formatInjectedFile(listedPath, content) {
   return `${SESSION_INJECTION_SECTION_PREFIX}: ${listedPath}
 ${content}`;
 }
+function formatInjectionWarning(error, listedPath) {
+  const isAbsent = error instanceof Error && "code" in error && error.code === SESSION_FILE_ERROR_CODE.NOT_FOUND;
+  const prefix = isAbsent ? SESSION_INJECTION_MISSING_WARNING_PREFIX : SESSION_INJECTION_UNREADABLE_WARNING_PREFIX;
+  return `${prefix}: ${listedPath}`;
+}
 async function readInjectedFiles(metadata, cwd, deps, onWarning) {
   const sections = [];
   for (const listedPath of [...metadata.specs, ...metadata.files]) {
@@ -7444,11 +7521,7 @@ async function readInjectedFiles(metadata, cwd, deps, onWarning) {
       const content = await deps.readFile(injectionPath(cwd, listedPath), SESSION_FILE_ENCODING);
       sections.push(formatInjectedFile(listedPath, content));
     } catch (error) {
-      if (error instanceof Error && "code" in error && error.code === SESSION_FILE_ERROR_CODE.NOT_FOUND) {
-        onWarning?.(`${SESSION_INJECTION_MISSING_WARNING_PREFIX}: ${listedPath}`);
-        continue;
-      }
-      throw error;
+      onWarning?.(formatInjectionWarning(error, listedPath));
     }
   }
   return sections;
@@ -7672,12 +7745,12 @@ async function releaseCommand(options) {
 }
 
 // src/commands/session/show.ts
-import { readFile as readFile7, stat as stat3 } from "fs/promises";
+import { readFile as readFile7, stat as stat4 } from "fs/promises";
 async function findExistingPath(paths, _config) {
   for (let i = 0; i < paths.length; i++) {
     const filePath = paths[i];
     try {
-      const stats = await stat3(filePath);
+      const stats = await stat4(filePath);
       if (stats.isFile()) {
         return { path: filePath, status: SEARCH_ORDER[i] };
       }
@@ -8119,13 +8192,13 @@ function spawnManagedSubprocess(runner, command, args, options) {
 var LAUNCH_FAILURE_STATUS = 1;
 function launchAgent(runner, suspender, command) {
   const restoreSignals = suspender.suspend();
-  return new Promise((resolve10) => {
+  return new Promise((resolve11) => {
     let settled = false;
     const settle = (status) => {
       if (settled) return;
       settled = true;
       restoreSignals();
-      resolve10(status);
+      resolve11(status);
     };
     const child = runner.spawn(command.command, command.args, { stdio: "inherit" });
     child.once("exit", (code) => settle(code ?? LAUNCH_FAILURE_STATUS));
@@ -8260,17 +8333,17 @@ async function readStdin() {
   if (process.stdin.isTTY) {
     return void 0;
   }
-  return new Promise((resolve10) => {
+  return new Promise((resolve11) => {
     let data = "";
     process.stdin.setEncoding(SESSION_FILE_ENCODING);
     process.stdin.on("data", (chunk) => {
       data += chunk;
     });
     process.stdin.on("end", () => {
-      resolve10(data.length === 0 ? void 0 : data);
+      resolve11(data.length === 0 ? void 0 : data);
     });
     process.stdin.on("error", () => {
-      resolve10(void 0);
+      resolve11(void 0);
     });
   });
 }
@@ -9953,17 +10026,56 @@ function createNodeStatusProvider(productDir) {
 // src/lib/node-status/update.ts
 import { mkdir as mkdir4, readdir as readdir7, rm, writeFile as writeFile2 } from "fs/promises";
 import { dirname as dirname7, join as join21 } from "path";
+
+// src/git/tracked-paths.ts
+var GIT_LS_FILES_SUBCOMMAND = "ls-files";
+var GIT_NUL_TERMINATED_FLAG = "-z";
+var TRACKED_PATH_NUL_SEPARATOR = "\0";
+var TRACKED_PATH_DIRECTORY_SEPARATOR = "/";
+var GIT_SUCCESS_EXIT_CODE = 0;
+async function listTrackedPaths(productDir, deps) {
+  let result;
+  try {
+    result = await deps.execa(
+      GIT_ROOT_COMMAND.EXECUTABLE,
+      [GIT_LS_FILES_SUBCOMMAND, GIT_NUL_TERMINATED_FLAG],
+      { cwd: productDir, reject: false }
+    );
+  } catch {
+    return void 0;
+  }
+  if (result.exitCode !== GIT_SUCCESS_EXIT_CODE) return void 0;
+  return new Set(result.stdout.split(TRACKED_PATH_NUL_SEPARATOR).filter((entry) => entry.length > 0));
+}
+function createTrackedPathInclusion(trackedPaths) {
+  if (trackedPaths === void 0) return () => true;
+  const admitted = new Set(trackedPaths);
+  for (const trackedPath of trackedPaths) {
+    let separatorIndex = trackedPath.indexOf(TRACKED_PATH_DIRECTORY_SEPARATOR);
+    while (separatorIndex !== -1) {
+      admitted.add(trackedPath.slice(0, separatorIndex));
+      separatorIndex = trackedPath.indexOf(TRACKED_PATH_DIRECTORY_SEPARATOR, separatorIndex + 1);
+    }
+  }
+  return (path7) => admitted.has(path7);
+}
+
+// src/lib/node-status/update.ts
 var NODE_STATUS_TEXT_ENCODING = "utf8";
 async function updateNodeStatus(options) {
-  const { productDir, resolveOutcome } = options;
+  const { productDir, resolveOutcome, gitDependencies = defaultGitDependencies } = options;
   const snapshot = await readSpecTree({ source: createFilesystemSpecTreeSource({ productDir }) });
   const ignoreReader = createIgnoreSourceReader(productDir, {
     ignoreSourceFilename: IGNORE_SOURCE_FILENAME_DEFAULT,
     specTreeRootSegment: SPEC_TREE_CONFIG.ROOT_DIRECTORY
   });
+  const isTrackedNodeDirectory = createTrackedPathInclusion(await listTrackedPaths(productDir, gitDependencies));
   const evidenceByNode = collectEvidenceByNode(snapshot);
   const liveStatusPaths = /* @__PURE__ */ new Set();
   for (const node of snapshot.allNodes) {
+    if (!isTrackedNodeDirectory(`${SPEC_TREE_CONFIG.ROOT_DIRECTORY}${TRACKED_PATH_DIRECTORY_SEPARATOR}${node.id}`)) {
+      continue;
+    }
     const evidence = evidenceByNode.get(node.id) ?? [];
     const verification = await resolveVerification(node, {
       evidence,
@@ -10163,13 +10275,14 @@ async function statusCommand(options = {}) {
     }
     return renderSpecStatus(projectSpecTree(await readSpecTree({ source: options.source })), options.format);
   }
+  const gitDependencies = options.gitDependencies ?? defaultGitDependencies;
   const productDir = await resolveSpecProductDir(
     options.cwd ?? CONFIG_PROCESS_CWD.read(),
-    options.gitDependencies,
+    gitDependencies,
     options.onWarning
   );
   if (options.update === true) {
-    await updateNodeStatus({ productDir, resolveOutcome: options.resolveOutcomeFor(productDir) });
+    await updateNodeStatus({ productDir, resolveOutcome: options.resolveOutcomeFor(productDir), gitDependencies });
   }
   const snapshot = await readSpecTree({
     source: createFilesystemSpecTreeSource({ productDir }),
@@ -10859,8 +10972,12 @@ function createTestingDomain(deps) {
 }
 var testingDomain = createTestingDomain();
 
+// src/interfaces/cli/validation.ts
+import { existsSync as existsSync8, realpathSync } from "fs";
+import { isAbsolute as isAbsolute9, relative as relative9, resolve as resolve10, sep as sep3 } from "path";
+
 // src/commands/validation/formatting.ts
-import { existsSync } from "fs";
+import { existsSync, statSync } from "fs";
 import { isAbsolute as isAbsolute3, join as join24, relative as relative3 } from "path";
 
 // src/validation/config/path-filter.ts
@@ -10870,11 +10987,24 @@ function hasEffectiveValidationPathMetadata(filter) {
   return "hasIncludeFilter" in filter && typeof filter.hasIncludeFilter === "boolean" && "noMatchingIncludes" in filter && typeof filter.noMatchingIncludes === "boolean";
 }
 function normalizePathPrefix2(prefix) {
-  return prefix.split(/[\\/]/g).join(PATH_PREFIX_SEPARATOR).replace(/^\.\//, "").replace(/\/+$/, "");
+  const normalizedSeparators = prefix.split("\\").join(PATH_PREFIX_SEPARATOR);
+  const withoutLeadingDot = normalizedSeparators.startsWith(`.${PATH_PREFIX_SEPARATOR}`) ? normalizedSeparators.slice(2) : normalizedSeparators;
+  const normalized = trimTrailingPathSeparators(withoutLeadingDot);
+  return normalized === "." ? "" : normalized;
+}
+function trimTrailingPathSeparators(path7) {
+  let end = path7.length;
+  while (end > 0 && path7[end - 1] === PATH_PREFIX_SEPARATOR) {
+    end -= 1;
+  }
+  return path7.slice(0, end);
 }
 function pathMatchesPrefix2(path7, prefix) {
   const normalizedPath = normalizePathPrefix2(path7);
   const normalizedPrefix = normalizePathPrefix2(prefix);
+  if (normalizedPrefix.length === 0) {
+    return true;
+  }
   return normalizedPath === normalizedPrefix || normalizedPath.startsWith(`${normalizedPrefix}${PATH_PREFIX_SEPARATOR}`);
 }
 function unique(values) {
@@ -10930,6 +11060,27 @@ function pathPassesValidationFilter(path7, filter) {
   }
   return !exclude.some((prefix) => pathMatchesPrefix2(path7, prefix));
 }
+function pathIntersectsValidationFilter(path7, filter) {
+  return validationPathFilterIntersections(path7, filter).length > 0;
+}
+function validationPathFilterExcludes(filter) {
+  return unique(nonEmpty(filter.exclude).map(normalizePathPrefix2));
+}
+function validationPathFilterIntersections(path7, filter) {
+  if (hasEffectiveValidationPathMetadata(filter) && filter.noMatchingIncludes) {
+    return [];
+  }
+  const normalizedPath = normalizePathPrefix2(path7);
+  const include = nonEmpty(filter.include);
+  const exclude = nonEmpty(filter.exclude);
+  const candidates = include.length > 0 ? include.flatMap((prefix) => {
+    const normalizedPrefix = normalizePathPrefix2(prefix);
+    if (pathMatchesPrefix2(normalizedPath, normalizedPrefix)) return [normalizedPath];
+    if (pathMatchesPrefix2(normalizedPrefix, normalizedPath)) return [normalizedPrefix];
+    return [];
+  }) : [normalizedPath];
+  return unique(candidates).filter((candidate) => !exclude.some((prefix) => pathMatchesPrefix2(candidate, prefix)));
+}
 function applyValidationPathFilterToScope(scopeConfig, filter) {
   if (!hasValidationPathFilter(filter)) {
     return scopeConfig;
@@ -10945,7 +11096,14 @@ function applyValidationPathFilterToScope(scopeConfig, filter) {
     (include) => scopeConfig.directories.some((directory) => pathMatchesPrefix2(include, directory))
   );
   const noMatchingIncludes = hasEffectiveMetadata && filter.noMatchingIncludes || hasIncludeFilter && scopedDirectories.length === 0 && scopedFilePatterns.length === 0 && includeFallbacksWithinScope.length === 0;
-  const directories = noMatchingIncludes ? [] : scopedDirectories.length > 0 ? scopedDirectories : includeFallbacksWithinScope;
+  let directories;
+  if (noMatchingIncludes) {
+    directories = [];
+  } else if (scopedDirectories.length > 0) {
+    directories = scopedDirectories;
+  } else {
+    directories = includeFallbacksWithinScope;
+  }
   const filePatterns = scopedFilePatterns.length > 0 ? scopedFilePatterns : [...directories];
   return {
     ...scopeConfig,
@@ -10991,14 +11149,23 @@ function forwardChunkWithBackpressure(source, stream, chunk) {
 // src/validation/steps/formatting.ts
 var DPRINT_COMMAND = "dprint";
 var DPRINT_CHECK_SUBCOMMAND = "check";
+var DPRINT_EXCLUDES_OPTION = "--excludes";
+var DPRINT_OPTIONS_TERMINATOR = "--";
 var DPRINT_CONFIG_FILENAME = "dprint.jsonc";
 var defaultFormattingProcessRunner = lifecycleProcessRunner;
 function buildDprintCheckArgs(options) {
-  return [DPRINT_CHECK_SUBCOMMAND, ...options.files ?? []];
+  const excludes = options.excludes ?? [];
+  const files = options.files ?? [];
+  return [
+    DPRINT_CHECK_SUBCOMMAND,
+    ...excludes.length > 0 ? [DPRINT_EXCLUDES_OPTION, ...excludes] : [],
+    ...files.length > 0 ? [DPRINT_OPTIONS_TERMINATOR] : [],
+    ...files
+  ];
 }
 async function validateFormatting(context, runner = defaultFormattingProcessRunner) {
-  const args = buildDprintCheckArgs({ files: context.files });
-  return new Promise((resolve10) => {
+  const args = buildDprintCheckArgs({ files: context.files, excludes: context.excludes });
+  return new Promise((resolve11) => {
     const child = spawnManagedSubprocess(runner, DPRINT_COMMAND, args, { cwd: context.projectRoot });
     const chunks = [];
     const capture = (chunk) => {
@@ -11007,10 +11174,10 @@ async function validateFormatting(context, runner = defaultFormattingProcessRunn
     child.stdout?.on(VALIDATION_SUBPROCESS_EVENTS.DATA, capture);
     child.stderr?.on(VALIDATION_SUBPROCESS_EVENTS.DATA, capture);
     child.on(VALIDATION_SUBPROCESS_EVENTS.CLOSE, (code) => {
-      resolve10({ success: code === 0, output: chunks.join("") });
+      resolve11({ success: code === 0, output: chunks.join("") });
     });
     child.on(VALIDATION_SUBPROCESS_EVENTS.ERROR, (error) => {
-      resolve10({ success: false, output: chunks.join(""), error: error.message });
+      resolve11({ success: false, output: chunks.join(""), error: error.message });
     });
   });
 }
@@ -11032,7 +11199,7 @@ var VALIDATION_SKIP_LABELS = {
   DISABLED_BY_PREFIX: "disabled by",
   TYPESCRIPT_ABSENT_REASON: "TypeScript not detected in project",
   VALIDATION_PATHS_NO_TARGETS_REASON: "validation paths matched no files",
-  MARKDOWN_NO_SCOPE_REASON: "no markdown files in --files scope",
+  MARKDOWN_NO_SCOPE_REASON: "no markdown files in explicit path scope",
   MARKDOWN_NO_DEFAULT_DIRECTORIES_REASON: "no spx/ or docs/ directories found"
 };
 var VALIDATION_COMMAND_OUTPUT = {
@@ -11077,6 +11244,7 @@ var FORMATTING_COMMAND_OUTPUT = {
   NO_CONFIG_SKIP_REASON: `no ${DPRINT_CONFIG_FILENAME} at product root`
 };
 var FORMATTING_CONFIG_ERROR_MESSAGE = `${VALIDATION_STAGE_DISPLAY_NAMES.FORMATTING}: \u2717 config error`;
+var DPRINT_RECURSIVE_DIRECTORY_GLOB_SUFFIX = "/**/*";
 async function formattingCommand(options) {
   const { cwd, files, quiet } = options;
   const startTime = Date.now();
@@ -11098,12 +11266,22 @@ async function formattingCommand(options) {
     VALIDATION_PATH_TOOL_SUBSECTIONS.FORMATTING
   );
   const hasExplicitScope = files !== void 0 && files.length > 0;
-  const scopedFiles = hasExplicitScope ? files.map((filePath) => isAbsolute3(filePath) ? relative3(cwd, filePath) : filePath).filter((relativePath) => pathPassesValidationFilter(relativePath, pathFilter)) : void 0;
+  const scopedFiles = hasExplicitScope ? files.flatMap(
+    (filePath) => formattingPathOperandsForValidationPathFilter(
+      cwd,
+      isAbsolute3(filePath) ? relative3(cwd, filePath) : filePath,
+      pathFilter
+    )
+  ) : void 0;
   if (hasExplicitScope && (scopedFiles === void 0 || scopedFiles.length === 0)) {
     const output2 = quiet ? "" : `${VALIDATION_STAGE_DISPLAY_NAMES.FORMATTING}: skipped (${FORMATTING_COMMAND_OUTPUT.EMPTY_SCOPE_REASON})`;
     return { exitCode: 0, output: output2, durationMs: Date.now() - startTime };
   }
-  const result = await validateFormatting({ projectRoot: cwd, files: scopedFiles });
+  const result = await validateFormatting({
+    projectRoot: cwd,
+    files: scopedFiles,
+    excludes: validationPathFilterExcludes(pathFilter)
+  });
   const durationMs = Date.now() - startTime;
   if (result.success) {
     return { exitCode: 0, output: quiet ? "" : FORMATTING_COMMAND_OUTPUT.NO_ISSUES, durationMs };
@@ -11112,6 +11290,24 @@ async function formattingCommand(options) {
   const output = [FORMATTING_COMMAND_OUTPUT.FAILURE_SUMMARY, detail].filter((line) => line.length > 0).join("\n");
   return { exitCode: 1, output, durationMs };
 }
+function normalizeFormattingPathOperand(productDir, relativePath) {
+  const absolutePath = join24(productDir, relativePath);
+  if (!existsSync(absolutePath) || !statSync(absolutePath).isDirectory()) {
+    return relativePath;
+  }
+  const normalizedDirectory = trimTrailingPathSeparators(relativePath);
+  if (normalizedDirectory.length === 0 || normalizedDirectory === ".") {
+    return DPRINT_RECURSIVE_DIRECTORY_GLOB_SUFFIX.slice(1);
+  }
+  return `${normalizedDirectory}${DPRINT_RECURSIVE_DIRECTORY_GLOB_SUFFIX}`;
+}
+function formattingPathOperandsForValidationPathFilter(productDir, relativePath, pathFilter) {
+  const absolutePath = join24(productDir, relativePath);
+  if (!existsSync(absolutePath) || !statSync(absolutePath).isDirectory()) {
+    return pathPassesValidationFilter(relativePath, pathFilter) ? [relativePath] : [];
+  }
+  return validationPathFilterIntersections(relativePath, pathFilter).map((path7) => normalizeFormattingPathOperand(productDir, path7));
+}
 
 // src/validation/languages/formatting.ts
 var FORMATTING_LANGUAGE_NAME = "formatting";
@@ -11127,10 +11323,10 @@ var formattingValidationLanguage = {
 };
 
 // src/commands/validation/markdown.ts
-import { relative as relative4 } from "path";
+import { isAbsolute as isAbsolute4, join as join26, relative as relative4 } from "path";
 
 // src/validation/steps/markdown.ts
-import { existsSync as existsSync2, statSync } from "fs";
+import { existsSync as existsSync2, statSync as statSync2 } from "fs";
 import { basename as basename4, dirname as dirname9, join as join25, relative as pathRelative } from "path";
 import { main as markdownlintMain } from "markdownlint-cli2";
 import relativeLinksRule from "markdownlint-rule-relative-links";
@@ -11154,9 +11350,8 @@ var MARKDOWN_VALIDATION_TARGET_KIND = {
 var MARKDOWN_VALIDATION_TARGET_DIAGNOSTICS = {
   MISSING_OR_UNRELATED_SCOPE: "not an existing directory or markdown file"
 };
-var ERROR_LINE_PATTERN = /^(.+?):(\d+)(?::\d+)?\s+(.+)$/;
 var defaultMarkdownValidationTargetDeps = {
-  statSync
+  statSync: statSync2
 };
 function buildMarkdownlintConfig(directoryName) {
   const md024Disabled = MD024_DISABLED_DIRECTORIES.includes(
@@ -11199,25 +11394,71 @@ function parseErrorLine(line) {
   if (DATA_URI_PATTERN.test(line)) {
     return null;
   }
-  const match = ERROR_LINE_PATTERN.exec(line);
-  if (!match) {
-    return null;
+  const parsed = parseMarkdownlintErrorLine(line);
+  if (parsed === null) return null;
+  return {
+    file: parsed.file,
+    line: Number.parseInt(parsed.line, 10),
+    detail: parsed.detail
+  };
+}
+function parseMarkdownlintErrorLine(line) {
+  for (let fileSeparator = line.indexOf(":"); fileSeparator > 0; fileSeparator = line.indexOf(":", fileSeparator + 1)) {
+    const parsed = parseMarkdownlintErrorLineAtSeparator(line, fileSeparator);
+    if (parsed !== null) return parsed;
   }
-  const [, file, lineStr, detail] = match;
+  return null;
+}
+function parseMarkdownlintErrorLineAtSeparator(line, fileSeparator) {
+  const lineStart = fileSeparator + 1;
+  const lineEnd = scanDigits(line, lineStart);
+  if (lineEnd === lineStart) return null;
+  const detailStart = scanMarkdownlintColumnAndWhitespace(line, lineEnd);
+  if (detailStart === null || detailStart >= line.length) return null;
   return {
-    file,
-    line: parseInt(lineStr, 10),
-    detail
+    file: line.slice(0, fileSeparator),
+    line: line.slice(lineStart, lineEnd),
+    detail: line.slice(detailStart)
   };
 }
+function scanDigits(value, start) {
+  let index = start;
+  while (index < value.length && isAsciiDigit(value[index] ?? "")) {
+    index += 1;
+  }
+  return index;
+}
+function scanMarkdownlintColumnAndWhitespace(value, start) {
+  let index = start;
+  if (value[index] === ":") {
+    const columnStart = index + 1;
+    index = scanDigits(value, columnStart);
+    if (index === columnStart) return null;
+  }
+  if (!isAsciiWhitespace(value[index] ?? "")) return null;
+  while (index < value.length && isAsciiWhitespace(value[index] ?? "")) {
+    index += 1;
+  }
+  return index;
+}
+function isAsciiDigit(value) {
+  return value >= "0" && value <= "9";
+}
+function isAsciiWhitespace(value) {
+  return value === " " || value === "	";
+}
 async function validateMarkdown(options) {
-  const { targets, projectRoot } = options;
+  const { targets, projectRoot, validationPathExcludes = [] } = options;
   const errors = [];
-  const excludeGlobs = getExcludeGlobs(projectRoot);
+  const specTreeExcludeGlobs = getExcludeGlobs(projectRoot);
   for (const target of targets) {
     const directory = targetDirectory(target);
     const dirName = markdownlintConfigDirectoryName(directory, projectRoot);
     const config = buildMarkdownlintConfig(dirName);
+    const excludeGlobs = [
+      ...specTreeExcludeGlobs,
+      ...validationPathExcludeGlobsForTarget(target, projectRoot, validationPathExcludes)
+    ];
     const dirErrors = await validateTarget(target, config, projectRoot, excludeGlobs);
     errors.push(...dirErrors);
   }
@@ -11263,6 +11504,32 @@ async function validateTarget(target, config, projectRoot, ignoreGlobs = []) {
 function targetDirectory(target) {
   return target.kind === MARKDOWN_VALIDATION_TARGET_KIND.FILE ? dirname9(target.path) : target.path;
 }
+function validationPathExcludeGlobsForTarget(target, projectRoot, excludes) {
+  if (projectRoot === void 0 || excludes.length === 0) return [];
+  const directory = targetDirectory(target);
+  const targetPath = normalizePathPrefix2(pathRelative(projectRoot, directory));
+  return excludes.flatMap((exclude) => {
+    const excludedPath = normalizePathPrefix2(exclude);
+    if (pathContainsValidationPath(excludedPath, targetPath)) {
+      return [MARKDOWN_DIRECTORY_GLOB];
+    }
+    if (!pathContainsValidationPath(targetPath, excludedPath)) {
+      return [];
+    }
+    const relativeExclude = normalizePathPrefix2(pathRelative(directory, join25(projectRoot, excludedPath)));
+    if (relativeExclude.length === 0) {
+      return [MARKDOWN_DIRECTORY_GLOB];
+    }
+    const absoluteExclude = join25(projectRoot, excludedPath);
+    return [
+      isExistingFile(absoluteExclude, defaultMarkdownValidationTargetDeps) ? relativeExclude : `${relativeExclude}/**`
+    ];
+  });
+}
+function pathContainsValidationPath(prefix, path7) {
+  if (prefix.length === 0) return true;
+  return path7 === prefix || path7.startsWith(`${prefix}/`);
+}
 function hasMarkdownExtension(path7) {
   const lastDot = path7.lastIndexOf(".");
   if (lastDot < 0) return false;
@@ -11315,11 +11582,12 @@ async function markdownCommand(options) {
     validationConfig.paths,
     VALIDATION_PATH_TOOL_SUBSECTIONS.MARKDOWN
   );
-  const targetResolutions = files && files.length > 0 ? files.map((filePath) => resolveMarkdownValidationTarget(filePath)) : void 0;
+  const targetResolutions = files && files.length > 0 ? files.map((filePath) => resolveMarkdownValidationTarget(markdownValidationOperandPath(cwd, filePath))) : void 0;
+  const explicitTargets = targetResolutions === void 0 ? void 0 : targetResolutions.map((resolution) => resolution.target).filter((target) => target !== void 0).flatMap((target) => markdownTargetsForValidationPathFilter(cwd, target, pathFilter));
   const unfilteredTargets = targetResolutions === void 0 ? getDefaultDirectories(cwd).map((path7) => ({
     kind: MARKDOWN_VALIDATION_TARGET_KIND.DIRECTORY,
     path: path7
-  })) : targetResolutions.map((resolution) => resolution.target).filter((target) => target !== void 0);
+  })) : explicitTargets ?? [];
   const targets = unfilteredTargets.filter(
     (target) => pathPassesValidationFilter(relative4(cwd, target.path), pathFilter)
   );
@@ -11335,11 +11603,22 @@ async function markdownCommand(options) {
   }
   const result = await validateMarkdown({
     targets,
-    projectRoot: cwd
+    projectRoot: cwd,
+    validationPathExcludes: validationPathFilterExcludes(pathFilter)
   });
   const durationMs = Date.now() - startTime;
   return formatMarkdownResult(result, skippedOutput, quiet, durationMs);
 }
+function markdownValidationOperandPath(productDir, filePath) {
+  return isAbsolute4(filePath) ? filePath : join26(productDir, filePath);
+}
+function markdownTargetsForValidationPathFilter(productDir, target, pathFilter) {
+  const relativePath = relative4(productDir, target.path);
+  if (target.kind === MARKDOWN_VALIDATION_TARGET_KIND.FILE) {
+    return pathPassesValidationFilter(relativePath, pathFilter) ? [target] : [];
+  }
+  return validationPathFilterIntersections(relativePath, pathFilter).map((path7) => resolveMarkdownValidationTarget(markdownValidationOperandPath(productDir, path7)).target).filter((filteredTarget) => filteredTarget !== void 0);
+}
 function formatSkippedFileScope(target) {
   return `${MARKDOWN_COMMAND_OUTPUT.SKIPPED_FILE_SCOPE_PREFIX}: ${target.path} (${target.reason})`;
 }
@@ -12233,7 +12512,7 @@ var ParseErrorCode;
 
 // src/validation/config/scope.ts
 import { existsSync as existsSync3, readdirSync, readFileSync as readFileSync3 } from "fs";
-import { isAbsolute as isAbsolute4, join as join26, relative as relative5, resolve as resolve8 } from "path";
+import { isAbsolute as isAbsolute5, join as join27, relative as relative5, resolve as resolve8 } from "path";
 var TSCONFIG_FILES = {
   full: "tsconfig.json",
   production: "tsconfig.production.json"
@@ -12270,7 +12549,7 @@ var EXPLICIT_TYPESCRIPT_SCOPE_TARGET_KIND = {
   FILE: "file"
 };
 function resolveProjectPath(projectRoot, path7) {
-  return isAbsolute4(path7) ? path7 : join26(projectRoot, path7);
+  return isAbsolute5(path7) ? path7 : join27(projectRoot, path7);
 }
 function parseTypeScriptConfig(configPath, deps = defaultScopeDeps) {
   try {
@@ -12309,12 +12588,12 @@ function hasTypeScriptFilesRecursive(dirPath, maxDepth = 2, deps = defaultScopeD
   try {
     const items = deps.readdirSync(dirPath, { withFileTypes: true });
     const hasDirectTsFiles = items.some(
-      (item) => item.isFile() && pathHasTypeScriptSourceExtension(item.name) && pathPassesTypeScriptFileDiscoveryExcludes(join26(dirPath, item.name), options)
+      (item) => item.isFile() && pathHasTypeScriptSourceExtension(item.name) && pathPassesTypeScriptFileDiscoveryExcludes(join27(dirPath, item.name), options)
     );
     if (hasDirectTsFiles) return true;
     const subdirs = items.filter((item) => item.isDirectory() && !item.name.startsWith("."));
     for (const subdir of subdirs.slice(0, 5)) {
-      if (hasTypeScriptFilesRecursive(join26(dirPath, subdir.name), maxDepth - 1, deps, options)) {
+      if (hasTypeScriptFilesRecursive(join27(dirPath, subdir.name), maxDepth - 1, deps, options)) {
         return true;
       }
     }
@@ -12351,7 +12630,7 @@ function directoryContributesTypeScriptScope(dir, config, projectRoot, deps) {
     return false;
   }
   try {
-    return hasTypeScriptFilesRecursive(join26(projectRoot, dir), 2, deps, {
+    return hasTypeScriptFilesRecursive(join27(projectRoot, dir), 2, deps, {
       excludePatterns: config.exclude,
       projectRoot
     });
@@ -12580,13 +12859,13 @@ function normalizeActiveIncludePattern(pattern, projectRoot, deps) {
 function filterActiveIncludePatterns(patterns, excludePatterns, projectRoot, deps) {
   return patterns.map((pattern) => normalizeActiveIncludePattern(pattern, projectRoot, deps)).filter((pattern) => typeScriptScopePatternTargetsTypeScriptSource(pattern)).filter((pattern) => {
     const topLevelDir = getLiteralTopLevelPatternDirectory(pattern);
-    return topLevelDir === null || deps.existsSync(join26(projectRoot, topLevelDir));
+    return topLevelDir === null || deps.existsSync(join27(projectRoot, topLevelDir));
   }).filter((pattern) => pathPassesValidationFilter(pattern, { exclude: excludePatterns }));
 }
 function getValidationDirectories(scope2, projectRoot, deps = defaultScopeDeps) {
   const config = resolveTypeScriptConfig(scope2, projectRoot, deps);
   const configDirectories = getTopLevelDirectoriesWithTypeScript(config, projectRoot, deps);
-  const existingDirectories = configDirectories.filter((dir) => deps.existsSync(join26(projectRoot, dir)));
+  const existingDirectories = configDirectories.filter((dir) => deps.existsSync(join27(projectRoot, dir)));
   return existingDirectories;
 }
 function getTypeScriptScope(scope2, projectRoot, deps = defaultScopeDeps) {
@@ -12607,13 +12886,13 @@ function pathPassesTypeScriptScope(path7, scopeConfig) {
   return included && !excluded;
 }
 function pathStaysInsideTypeScriptScopeRoot(projectRoot, path7) {
-  const resolvedPath = isAbsolute4(path7) ? resolve8(path7) : resolve8(projectRoot, path7);
+  const resolvedPath = isAbsolute5(path7) ? resolve8(path7) : resolve8(projectRoot, path7);
   const relativePath = relative5(projectRoot, resolvedPath);
   const segments = normalizeTypeScriptScopePath(relativePath).split(PATH_SEGMENT_SEPARATOR3);
-  return relativePath.length === 0 || !segments.includes("..") && !isAbsolute4(relativePath);
+  return relativePath.length === 0 || !segments.includes("..") && !isAbsolute5(relativePath);
 }
 function toProjectRelativeTypeScriptScopePath(projectRoot, path7) {
-  const resolvedPath = isAbsolute4(path7) ? resolve8(path7) : resolve8(projectRoot, path7);
+  const resolvedPath = isAbsolute5(path7) ? resolve8(path7) : resolve8(projectRoot, path7);
   const relativePath = relative5(projectRoot, resolvedPath);
   return relativePath.length === 0 ? TYPESCRIPT_SCOPE_PROJECT_ROOT : normalizeTypeScriptScopePath(relativePath);
 }
@@ -12632,7 +12911,10 @@ function filterExplicitTypeScriptScopeTargets(filter, deps = defaultScopeDeps) {
   if (paths === void 0) {
     return void 0;
   }
-  return paths.filter((path7) => pathStaysInsideTypeScriptScopeRoot(projectRoot, path7)).map((path7) => toExplicitTypeScriptScopeTarget(projectRoot, path7, deps)).filter((target) => !requireExistingPaths || explicitTypeScriptScopeTargetExists(projectRoot, target, deps)).filter((target) => explicitTypeScriptScopeTargetPassesSourceKind(target)).filter((target) => pathPassesValidationFilter(target.path, validationPathFilter)).filter((target) => explicitTypeScriptScopeTargetPassesScope(target, scopeConfig));
+  return paths.filter((path7) => pathStaysInsideTypeScriptScopeRoot(projectRoot, path7)).map((path7) => toExplicitTypeScriptScopeTarget(projectRoot, path7, deps)).filter((target) => !requireExistingPaths || explicitTypeScriptScopeTargetExists(projectRoot, target, deps)).filter((target) => explicitTypeScriptScopeTargetPassesSourceKind(target)).filter((target) => explicitTypeScriptScopeTargetIntersectsValidationPathFilter(target, validationPathFilter)).filter((target) => explicitTypeScriptScopeTargetPassesScope(target, scopeConfig));
+}
+function explicitTypeScriptScopeTargetIntersectsValidationPathFilter(target, validationPathFilter) {
+  return target.kind === EXPLICIT_TYPESCRIPT_SCOPE_TARGET_KIND.DIRECTORY ? pathIntersectsValidationFilter(target.path, validationPathFilter) : pathPassesValidationFilter(target.path, validationPathFilter);
 }
 function explicitTypeScriptScopeTargetPassesSourceKind(target) {
   return target.kind === EXPLICIT_TYPESCRIPT_SCOPE_TARGET_KIND.DIRECTORY || pathHasTypeScriptSourceExtension(target.path);
@@ -12653,10 +12935,12 @@ function explicitTypeScriptScopeTargetPassesScope(target, scopeConfig) {
   if (typeScriptSourcePatterns.length > 0) {
     return typeScriptSourcePatterns.some((pattern) => typeScriptScopePatternIntersectsDirectory(pattern, target.path));
   }
-  return pathPassesTypeScriptScope(join26(target.path, TYPESCRIPT_SCOPE_DIRECTORY_PROBE_FILENAME), scopeConfig);
+  return scopeConfig.directories.some(
+    (directory) => pathMatchesLiteralPrefix(directory, target.path) || pathMatchesLiteralPrefix(target.path, directory)
+  ) || pathPassesTypeScriptScope(join27(target.path, TYPESCRIPT_SCOPE_DIRECTORY_PROBE_FILENAME), scopeConfig);
 }
 function directoryPassesTypeScriptExcludes(directory, scopeConfig) {
-  const probePath = join26(directory, TYPESCRIPT_SCOPE_DIRECTORY_PROBE_FILENAME);
+  const probePath = join27(directory, TYPESCRIPT_SCOPE_DIRECTORY_PROBE_FILENAME);
   return !scopeConfig.excludePatterns.some(
     (pattern) => typeScriptScopePatternCoversDirectorySourceSet(pattern, directory) || pathMatchesTypeScriptPattern(probePath, pattern)
   );
@@ -12683,6 +12967,15 @@ function constrainTypeScriptScopeToExplicitTargets(scopeConfig, targets) {
   const retainedDirectoryFilePatterns = scopeConfig.filePatterns.filter(
     (pattern) => !typeScriptScopePatternHasGlob(pattern) && pathHasTypeScriptSourceExtension(pattern) && retainedDirectories.some((directory) => pathMatchesLiteralPrefix(pattern, directory))
   );
+  const retainedDirectoryPatterns = scopeConfig.filePatterns.filter(
+    (pattern) => !typeScriptScopePatternHasGlob(pattern) && !pathHasTypeScriptSourceExtension(pattern) && retainedDirectories.some((directory) => pathMatchesLiteralPrefix(pattern, directory))
+  ).map((pattern) => typeScriptLiteralDirectoryPattern(pattern));
+  const retainedDirectoryScopePatterns = retainedDirectories.filter(
+    (directory) => scopeConfig.filePatterns.some(
+      (pattern) => !typeScriptScopePatternHasGlob(pattern) && !pathHasTypeScriptSourceExtension(pattern) && pathMatchesLiteralPrefix(directory, pattern)
+    )
+  ).map((directory) => typeScriptLiteralDirectoryPattern(directory));
+  const retainedDirectoryOperandPatterns = scopeConfig.filePatterns.length === 0 ? retainedDirectories.map(typeScriptLiteralDirectoryPattern) : [];
   const explicitFileTargets = targets.filter((target) => target.kind === EXPLICIT_TYPESCRIPT_SCOPE_TARGET_KIND.FILE).map((target) => target.path).filter(
     (path7) => !retainedDirectories.some(
       (directory) => path7 === directory || path7.startsWith(`${directory}${PATH_SEGMENT_SEPARATOR3}`)
@@ -12695,12 +12988,20 @@ function constrainTypeScriptScopeToExplicitTargets(scopeConfig, targets) {
     ...scopeConfig,
     directories: retainedDirectories,
     filePatterns: [
-      ...scopedFilePatternsForDirectoryTargets,
-      ...retainedDirectoryFilePatterns,
-      ...uncoveredExplicitFileTargets
+      .../* @__PURE__ */ new Set([
+        ...scopedFilePatternsForDirectoryTargets,
+        ...retainedDirectoryFilePatterns,
+        ...retainedDirectoryPatterns,
+        ...retainedDirectoryScopePatterns,
+        ...retainedDirectoryOperandPatterns,
+        ...uncoveredExplicitFileTargets
+      ])
     ]
   };
 }
+function typeScriptLiteralDirectoryPattern(pattern) {
+  return pattern === TYPESCRIPT_SCOPE_PROJECT_ROOT ? TYPESCRIPT_SCOPE_DIRECTORY_PATTERN_SUFFIX.slice(1) : `${pattern}${TYPESCRIPT_SCOPE_DIRECTORY_PATTERN_SUFFIX}`;
+}
 function resolveTypeScriptValidationScope(filter, deps = defaultScopeDeps) {
   const scopeConfig = applyValidationPathFilterToScope(
     getTypeScriptScope(filter.scope, filter.projectRoot, deps),
@@ -12847,10 +13148,10 @@ function resolvedModulePath(resolvedPath) {
     return resolvedPath;
   }
 }
-function nearestPackageRoot(filePath, existsSync8) {
+function nearestPackageRoot(filePath, existsSync9) {
   let currentDirectory = path6.dirname(filePath);
   for (; ; ) {
-    if (existsSync8(path6.join(currentDirectory, PACKAGE_MANIFEST_FILENAME))) {
+    if (existsSync9(path6.join(currentDirectory, PACKAGE_MANIFEST_FILENAME))) {
       return currentDirectory;
     }
     const parentDirectory = path6.dirname(currentDirectory);
@@ -12860,9 +13161,9 @@ function nearestPackageRoot(filePath, existsSync8) {
     currentDirectory = parentDirectory;
   }
 }
-function bundledToolPath(resolvedPath, existsSync8) {
+function bundledToolPath(resolvedPath, existsSync9) {
   const bundledFilePath = resolvedModulePath(resolvedPath);
-  return nearestPackageRoot(bundledFilePath, existsSync8) ?? path6.dirname(bundledFilePath);
+  return nearestPackageRoot(bundledFilePath, existsSync9) ?? path6.dirname(bundledFilePath);
 }
 async function discoverTool(tool, options = {}) {
   const { projectRoot = CONFIG_PROCESS_CWD.read(), deps = defaultToolDiscoveryDeps } = options;
@@ -12919,7 +13220,7 @@ import {
   cruise as dependencyCruiser
 } from "dependency-cruiser";
 import extractTypeScriptConfig from "dependency-cruiser/config-utl/extract-ts-config";
-import { join as join27 } from "path";
+import { join as join28 } from "path";
 var DEPENDENCY_CRUISER_MODULE_SYSTEMS = ["es6", "cjs"];
 var DEPENDENCY_CRUISER_TYPESCRIPT_SOURCE_GLOB_SUFFIXES = [...TYPESCRIPT_FALLBACK_INCLUDE_PATTERNS];
 var DEPENDENCY_CRUISER_TYPESCRIPT_SOURCE_PATTERN = String.raw`(?<!\.d)\.(?:[cm]?ts|tsx)$`;
@@ -13159,7 +13460,7 @@ async function validateCircularDependencies(scope2, typescriptScope, projectRoot
     if (analyzeSourcePatterns.length === 0) {
       return { success: true };
     }
-    const tsConfigFile = join27(projectRoot, TSCONFIG_FILES[scope2]);
+    const tsConfigFile = join28(projectRoot, TSCONFIG_FILES[scope2]);
     const result = await deps.dependencyCruiser(
       analyzeSourcePatterns,
       buildDependencyCruiserOptions(typescriptScope, projectRoot, tsConfigFile),
@@ -13281,7 +13582,7 @@ async function circularCommand(options, deps = defaultCircularCommandDeps) {
 // src/validation/steps/knip.ts
 import { existsSync as existsSync4 } from "fs";
 import { mkdir as mkdir5, mkdtemp as mkdtemp2, rm as rm2, writeFile as writeFile3 } from "fs/promises";
-import { isAbsolute as isAbsolute5, join as join28 } from "path";
+import { isAbsolute as isAbsolute6, join as join29 } from "path";
 var defaultKnipProcessRunner = lifecycleProcessRunner;
 var KNIP_COMMAND_TOKENS = {
   COMMAND: "knip",
@@ -13314,7 +13615,7 @@ async function validateKnip2(context, runner = defaultKnipProcessRunner, deps =
 }
 async function runKnipSubprocess(projectRoot, typescriptScope, runner, deps) {
   const scopedTsconfig = typescriptScope.filteredByValidationPaths ? await createScopedKnipTsconfig(projectRoot, typescriptScope, deps) : void 0;
-  const localBin = join28(projectRoot, "node_modules", ".bin", "knip");
+  const localBin = join29(projectRoot, "node_modules", ".bin", "knip");
   const binary = deps.existsSync(localBin) ? localBin : KNIP_COMMAND_TOKENS.NPX_COMMAND;
   const baseArgs = scopedTsconfig === void 0 ? [] : [
     KNIP_COMMAND_TOKENS.USE_TSCONFIG_FILES_FLAG,
@@ -13344,13 +13645,13 @@ async function runKnipSubprocess(projectRoot, typescriptScope, runner, deps) {
   knipProcess.stderr?.on("data", (data) => {
     knipError += data.toString();
   });
-  return new Promise((resolve10) => {
+  return new Promise((resolve11) => {
     const resolveAfterCleanup = (result) => {
       if (resultResolved) {
         return;
       }
       resultResolved = true;
-      void cleanupOnce().finally(() => resolve10(result));
+      void cleanupOnce().finally(() => resolve11(result));
     };
     knipProcess.on("close", (code) => {
       if (code === 0) {
@@ -13369,11 +13670,11 @@ async function runKnipSubprocess(projectRoot, typescriptScope, runner, deps) {
   });
 }
 async function createScopedKnipTsconfig(projectRoot, typescriptScope, deps) {
-  const tempParentDir = join28(projectRoot, ...TEMPORARY_TSCONFIG_PARENT_SEGMENTS);
+  const tempParentDir = join29(projectRoot, ...TEMPORARY_TSCONFIG_PARENT_SEGMENTS);
   await deps.mkdir(tempParentDir, { recursive: true });
-  const tempDir = await deps.mkdtemp(join28(tempParentDir, "validate-knip-"));
-  const configPath = join28(tempDir, TSCONFIG_FILES.full);
-  const toProjectPathPattern = (pattern) => isAbsolute5(pattern) ? pattern : join28(projectRoot, pattern);
+  const tempDir = await deps.mkdtemp(join29(tempParentDir, "validate-knip-"));
+  const configPath = join29(tempDir, TSCONFIG_FILES.full);
+  const toProjectPathPattern = (pattern) => isAbsolute6(pattern) ? pattern : join29(projectRoot, pattern);
   const project = [
     ...typescriptScope.directories.flatMap(
       (directory) => TYPESCRIPT_FALLBACK_INCLUDE_PATTERNS.map((pattern) => `${directory}/${pattern}`)
@@ -13381,7 +13682,7 @@ async function createScopedKnipTsconfig(projectRoot, typescriptScope, deps) {
     ...typescriptScope.filePatterns
   ];
   const config = {
-    extends: join28(projectRoot, TSCONFIG_FILES.full),
+    extends: join29(projectRoot, TSCONFIG_FILES.full),
     include: project.map(toProjectPathPattern),
     exclude: typescriptScope.excludePatterns.map(toProjectPathPattern)
   };
@@ -13448,12 +13749,12 @@ async function knipCommand(options, deps = defaultKnipCommandDeps) {
 
 // src/validation/steps/eslint.ts
 import { existsSync as existsSync6 } from "fs";
-import { join as join30 } from "path";
+import { join as join31 } from "path";
 
 // src/validation/lint-policy.ts
 import { execFileSync as execFileSync2 } from "child_process";
-import { existsSync as existsSync5, readdirSync as readdirSync2, readFileSync as readFileSync4, statSync as statSync2 } from "fs";
-import { join as join29 } from "path";
+import { existsSync as existsSync5, readdirSync as readdirSync2, readFileSync as readFileSync4, statSync as statSync3 } from "fs";
+import { join as join30 } from "path";
 
 // src/validation/lint-policy-constants.ts
 var LINT_POLICY_MANIFESTS = {
@@ -13501,17 +13802,17 @@ function isSpecTreeNodePath(entry) {
 }
 function readManifest2(productDir, file, key) {
   return parseLintPolicyManifest(
-    readFileSync4(join29(productDir, file), "utf-8"),
+    readFileSync4(join30(productDir, file), "utf-8"),
     file,
     key
   );
 }
 function manifestExists(productDir, file) {
-  return existsSync5(join29(productDir, file));
+  return existsSync5(join30(productDir, file));
 }
 function findDeprecatedSpecNodePath(productDir) {
   function visit2(relativeDirectory) {
-    const absoluteDirectory = join29(productDir, relativeDirectory);
+    const absoluteDirectory = join30(productDir, relativeDirectory);
     for (const entry of readdirSync2(absoluteDirectory, { withFileTypes: true })) {
       if (!entry.isDirectory()) {
         continue;
@@ -13527,7 +13828,7 @@ function findDeprecatedSpecNodePath(productDir) {
     }
     return void 0;
   }
-  const specTreeRootPath = join29(productDir, SPEC_TREE_ROOT);
+  const specTreeRootPath = join30(productDir, SPEC_TREE_ROOT);
   if (!existsSync5(specTreeRootPath)) {
     return void 0;
   }
@@ -13553,8 +13854,8 @@ function assertManifestEntries(productDir, file, entries, suffixPredicate, suffi
     if (!suffixPredicate(entry)) {
       throw new Error(`${file} entry must ${suffixDescription}: ${entry}`);
     }
-    const absoluteEntry = join29(productDir, entry);
-    if (!existsSync5(absoluteEntry) || !statSync2(absoluteEntry).isDirectory()) {
+    const absoluteEntry = join30(productDir, entry);
+    if (!existsSync5(absoluteEntry) || !statSync3(absoluteEntry).isDirectory()) {
       throw new Error(`${file} entry does not exist as a directory: ${entry}`);
     }
   }
@@ -13715,7 +14016,14 @@ var ESLINT_COMMAND_TOKENS = {
 };
 var ESLINT_LOCAL_BIN_SEGMENTS = ["node_modules", ".bin", ESLINT_COMMAND_TOKENS.COMMAND];
 function buildEslintArgs(context) {
-  const { validatedFiles, mode, configFile = DEFAULT_ESLINT_CONFIG_FILE, scope: scope2, scopeConfig } = context;
+  const {
+    validatedFiles,
+    validatedFileIgnorePatterns = [],
+    mode,
+    configFile = DEFAULT_ESLINT_CONFIG_FILE,
+    scope: scope2,
+    scopeConfig
+  } = context;
   const fixArg = mode === EXECUTION_MODES.WRITE ? [ESLINT_COMMAND_TOKENS.FIX_FLAG] : [];
   if (validatedFiles && validatedFiles.length > 0) {
     return [
@@ -13723,6 +14031,7 @@ function buildEslintArgs(context) {
       ESLINT_COMMAND_TOKENS.CONFIG_FLAG,
       configFile,
       ...fixArg,
+      ...buildIgnorePatternArgs(validatedFileIgnorePatterns),
       ESLINT_COMMAND_TOKENS.FILE_SEPARATOR,
       ...validatedFiles
     ];
@@ -13763,13 +14072,14 @@ async function validateESLint(context, runner = defaultEslintProcessRunner, outp
   }
   const eslintArgs = buildEslintArgs({
     validatedFiles,
+    validatedFileIgnorePatterns: context.validatedFileIgnorePatterns,
     mode,
     configFile: eslintConfigFile,
     scope: scope2,
     scopeConfig: context.scopeConfig
   });
-  return new Promise((resolve10) => {
-    const localBin = join30(projectRoot, ...ESLINT_LOCAL_BIN_SEGMENTS);
+  return new Promise((resolve11) => {
+    const localBin = join31(projectRoot, ...ESLINT_LOCAL_BIN_SEGMENTS);
     const binary = existsSync6(localBin) ? localBin : "npx";
     const spawnArgs = binary === "npx" ? eslintArgs : eslintArgs.slice(1);
     const eslintProcess = spawnManagedSubprocess(runner, binary, spawnArgs, {
@@ -13778,13 +14088,13 @@ async function validateESLint(context, runner = defaultEslintProcessRunner, outp
     forwardValidationSubprocessOutput(eslintProcess, outputStreams);
     eslintProcess.on(VALIDATION_SUBPROCESS_EVENTS.CLOSE, (code) => {
       if (code === 0) {
-        resolve10({ success: true });
+        resolve11({ success: true });
       } else {
-        resolve10({ success: false, error: `ESLint exited with code ${code}` });
+        resolve11({ success: false, error: `ESLint exited with code ${code}` });
       }
     });
     eslintProcess.on(VALIDATION_SUBPROCESS_EVENTS.ERROR, (error) => {
-      resolve10({ success: false, error: error.message });
+      resolve11({ success: false, error: error.message });
     });
   });
 }
@@ -13832,7 +14142,12 @@ async function lintCommand(options) {
     getTypeScriptScope(scope2, cwd),
     validationPathFilter
   );
-  const validatedFiles = files?.map((file) => toProjectRelativeValidationPath(cwd, file)).filter((file) => pathPassesValidationFilter(file, validationPathFilter));
+  const validatedFiles = files?.flatMap(
+    (file) => validationPathFilterIntersections(
+      toProjectRelativeValidationPath(cwd, file),
+      validationPathFilter
+    ).map(formatLintValidationOperand)
+  );
   if (scopeConfig.filteredByValidationPathNoMatches || files !== void 0 && files.length > 0 && validatedFiles?.length === 0) {
     return {
       exitCode: 0,
@@ -13852,6 +14167,7 @@ async function lintCommand(options) {
     mode: fix ? "write" : "read",
     enabledValidations: { ESLINT: true },
     validatedFiles,
+    validatedFileIgnorePatterns: files === void 0 ? void 0 : validationPathFilterExcludes(validationPathFilter),
     isFileSpecificMode: Boolean(validatedFiles && validatedFiles.length > 0),
     eslintConfigFile
   };
@@ -13859,6 +14175,9 @@ async function lintCommand(options) {
   const durationMs = Date.now() - startTime;
   return formatLintResult(result, quiet, durationMs);
 }
+function formatLintValidationOperand(path7) {
+  return path7.length === 0 ? "." : path7;
+}
 function formatLintResult(result, quiet, durationMs) {
   if (result.skipped) {
     const output2 = quiet ? "" : VALIDATION_PATHS_NO_TARGETS_MESSAGE;
@@ -13874,7 +14193,7 @@ function formatLintResult(result, quiet, durationMs) {
 
 // src/validation/literal/index.ts
 import { readFile as readFile9 } from "fs/promises";
-import { isAbsolute as isAbsolute6, relative as relative7, resolve as resolve9 } from "path";
+import { isAbsolute as isAbsolute7, relative as relative7, resolve as resolve9 } from "path";
 
 // src/lib/file-inclusion/predicates/ignore-source.ts
 var IGNORE_SOURCE_LAYER = "ignore-source";
@@ -13909,7 +14228,7 @@ var ignoreSourceLayer = makeLayer(
 
 // src/lib/file-inclusion/pipeline.ts
 import { readdir as readdir8 } from "fs/promises";
-import { join as join31, relative as relative6, sep as sep2 } from "path";
+import { join as join32, relative as relative6, sep as sep2 } from "path";
 var EXPLICIT_OVERRIDE_LAYER = "explicit-override";
 function isNodeError4(err) {
   return err instanceof Error && "code" in err;
@@ -13927,10 +14246,10 @@ async function collectPaths(absoluteDir, projectRoot, result, artifactDirs) {
   for (const entry of dirEntries) {
     if (entry.isDirectory()) {
       if (artifactDirs.has(entry.name)) continue;
-      const absolutePath = join31(absoluteDir, entry.name);
+      const absolutePath = join32(absoluteDir, entry.name);
       await collectPaths(absolutePath, projectRoot, result, artifactDirs);
     } else if (entry.isFile()) {
-      const absolutePath = join31(absoluteDir, entry.name);
+      const absolutePath = join32(absoluteDir, entry.name);
       const rel = relative6(projectRoot, absolutePath);
       result.push(sep2 === "/" ? rel : rel.split(sep2).join("/"));
     }
@@ -14442,9 +14761,9 @@ function applyPathFilter2(entries, pathConfig) {
 }
 async function validateLiteralReuse(input) {
   const config = input.config ?? literalConfigDescriptor.defaults;
-  const request = input.files ? {
+  const request = input.scopeConfig === void 0 && input.files ? {
     explicit: input.files.map((f) => {
-      const abs = isAbsolute6(f) ? f : resolve9(input.productDir, f);
+      const abs = isAbsolute7(f) ? f : resolve9(input.productDir, f);
       return relative7(input.productDir, abs).split(/[\\/]/g).join("/");
     })
   } : { walkRoot: input.productDir };
@@ -14455,7 +14774,9 @@ async function validateLiteralReuse(input) {
     DEFAULT_SCOPE_CONFIG,
     EMPTY_IGNORE_READER
   );
-  const filtered = applyPathFilter2(scope2.included, input.pathConfig);
+  const pathFiltered = applyPathFilter2(scope2.included, input.pathConfig);
+  const literalScopeConfig = input.scopeConfig;
+  const filtered = literalScopeConfig === void 0 ? pathFiltered : pathFiltered.filter((entry) => pathPassesTypeScriptScope(entry.path, literalScopeConfig));
   const candidateFiles = filtered.filter((entry) => isTypescriptSource(entry.path)).map((entry) => resolve9(input.productDir, entry.path));
   const collectOptions = {
     visitorKeys: defaultVisitorKeys,
@@ -14483,7 +14804,11 @@ async function validateLiteralReuse(input) {
     testOccurrencesByFile,
     allowlist: resolveAllowlist(config)
   });
-  return { findings, indexedOccurrencesByFile };
+  return {
+    findings,
+    indexedOccurrencesByFile,
+    filteredByValidationPathNoMatches: input.scopeConfig?.filteredByValidationPathNoMatches
+  };
 }
 async function readSafe(path7) {
   try {
@@ -14518,6 +14843,9 @@ var LITERAL_EXIT_CODES = {
 var TYPESCRIPT_ABSENT_MESSAGE3 = formatTypeScriptAbsentSkipMessage(
   VALIDATION_STAGE_DISPLAY_NAMES.LITERAL
 );
+var VALIDATION_PATHS_NO_TARGETS_MESSAGE2 = formatValidationPathsNoTargetsSkipMessage(
+  VALIDATION_STAGE_DISPLAY_NAMES.LITERAL
+);
 var LITERAL_DISABLED_MESSAGE = `\u23ED ${VALIDATION_SKIP_LABELS.VERB} ${VALIDATION_STAGE_DISPLAY_NAMES.LITERAL} (${VALIDATION_SKIP_LABELS.DISABLED_BY_PREFIX} validation.literal.enabled)`;
 var NO_PROBLEMS_MESSAGE = "Literal: \u2713 No problems";
 function formatNoProblemsOfKind(kind) {
@@ -14533,31 +14861,15 @@ async function literalCommand(options) {
       durationMs: Date.now() - start
     };
   }
-  let resolvedEnabled;
-  let resolvedLiteralConfig;
-  let resolvedPathConfig;
-  if (options.config === void 0) {
-    const loaded = await resolveConfig(options.cwd, [validationConfigDescriptor]);
-    if (!loaded.ok) {
-      return {
-        exitCode: LITERAL_EXIT_CODES.CONFIG_ERROR,
-        output: `Literal: \u2717 config error \u2014 ${loaded.error}`,
-        durationMs: Date.now() - start
-      };
-    }
-    const validationConfig = loaded.value[validationConfigDescriptor.section];
-    resolvedEnabled = validationConfig.literal.enabled;
-    resolvedLiteralConfig = validationConfig.literal.values;
-    resolvedPathConfig = validationPathFilterForTool(
-      validationConfig.paths,
-      VALIDATION_PATH_TOOL_SUBSECTIONS.LITERAL
-    );
-  } else {
-    resolvedEnabled = options.enabled ?? validationConfigDescriptor.defaults.literal.enabled;
-    resolvedLiteralConfig = options.config;
-    resolvedPathConfig = options.pathConfig ?? validationConfigDescriptor.defaults.paths;
+  const resolved = await resolveLiteralCommandConfig(options);
+  if (typeof resolved === "string") {
+    return {
+      exitCode: LITERAL_EXIT_CODES.CONFIG_ERROR,
+      output: `Literal: \u2717 config error \u2014 ${resolved}`,
+      durationMs: Date.now() - start
+    };
   }
-  if (!resolvedEnabled) {
+  if (!resolved.enabled) {
     return {
       exitCode: LITERAL_EXIT_CODES.OK,
       output: options.quiet ? "" : LITERAL_DISABLED_MESSAGE,
@@ -14566,10 +14878,17 @@ async function literalCommand(options) {
   }
   const result = await validateLiteralReuse({
     productDir: options.cwd,
-    files: options.files,
-    config: resolvedLiteralConfig,
-    pathConfig: resolvedPathConfig
+    config: resolved.literalConfig,
+    pathConfig: resolved.pathConfig,
+    scopeConfig: resolveExplicitLiteralTypeScriptScope(options, resolved.pathConfig)
   });
+  if (options.files !== void 0 && options.files.length > 0 && result.filteredByValidationPathNoMatches) {
+    return {
+      exitCode: LITERAL_EXIT_CODES.OK,
+      output: options.quiet ? "" : VALIDATION_PATHS_NO_TARGETS_MESSAGE2,
+      durationMs: Date.now() - start
+    };
+  }
   const filteredFindings = filterLiteralFindings(result.findings, options.kind);
   const totalProblems = countLiteralProblems(filteredFindings);
   const exitCode = totalProblems === 0 ? LITERAL_EXIT_CODES.OK : LITERAL_EXIT_CODES.FINDINGS;
@@ -14583,6 +14902,38 @@ async function literalCommand(options) {
   }
   return { exitCode, output, durationMs: Date.now() - start };
 }
+async function resolveLiteralCommandConfig(options) {
+  if (options.config !== void 0) {
+    return {
+      enabled: options.enabled ?? validationConfigDescriptor.defaults.literal.enabled,
+      literalConfig: options.config,
+      pathConfig: options.pathConfig ?? validationConfigDescriptor.defaults.paths
+    };
+  }
+  const loaded = await resolveConfig(options.cwd, [validationConfigDescriptor]);
+  if (!loaded.ok) return loaded.error;
+  const validationConfig = loaded.value[validationConfigDescriptor.section];
+  return {
+    enabled: validationConfig.literal.enabled,
+    literalConfig: validationConfig.literal.values,
+    pathConfig: validationPathFilterForTool(
+      validationConfig.paths,
+      VALIDATION_PATH_TOOL_SUBSECTIONS.LITERAL
+    )
+  };
+}
+function resolveExplicitLiteralTypeScriptScope(options, pathConfig) {
+  if (options.files === void 0 || options.files.length === 0) {
+    return void 0;
+  }
+  return resolveTypeScriptValidationScope({
+    projectRoot: options.cwd,
+    scope: options.scope ?? VALIDATION_SCOPES.FULL,
+    paths: options.files,
+    validationPathFilter: pathConfig,
+    markExplicitPathsAsValidationFilter: true
+  });
+}
 function filterLiteralFindings(findings, kind) {
   return {
     srcReuse: kind === LITERAL_PROBLEM_KIND.DUPE ? [] : sortReuseFindings(findings.srcReuse),
@@ -14706,7 +15057,7 @@ function formatLoc(loc) {
 // src/validation/steps/typescript.ts
 import { existsSync as existsSync7, mkdirSync, rmSync, writeFileSync } from "fs";
 import { mkdtemp as mkdtemp3 } from "fs/promises";
-import { isAbsolute as isAbsolute7, join as join32 } from "path";
+import { isAbsolute as isAbsolute8, join as join33, relative as relative8 } from "path";
 var defaultTypeScriptProcessRunner = lifecycleProcessRunner;
 var defaultTypeScriptDeps = {
   mkdtemp: mkdtemp3,
@@ -14718,9 +15069,9 @@ var defaultTypeScriptDeps = {
 var TEMPORARY_TSCONFIG_COMPILER_OPTIONS = { noEmit: true };
 var TEMPORARY_TSCONFIG_DIR_PREFIX = "validate-ts-";
 async function createTemporaryTsconfigDir(projectRoot, deps) {
-  const parent = join32(projectRoot, ...TEMPORARY_TSCONFIG_PARENT_SEGMENTS);
+  const parent = join33(projectRoot, ...TEMPORARY_TSCONFIG_PARENT_SEGMENTS);
   deps.mkdirSync(parent, { recursive: true });
-  return deps.mkdtemp(join32(parent, TEMPORARY_TSCONFIG_DIR_PREFIX));
+  return deps.mkdtemp(join33(parent, TEMPORARY_TSCONFIG_DIR_PREFIX));
 }
 function buildTypeScriptArgs(context) {
   const { scope: scope2, configFile } = context;
@@ -14728,11 +15079,11 @@ function buildTypeScriptArgs(context) {
 }
 async function createFileSpecificTsconfig(scope2, files, projectRoot, deps = defaultTypeScriptDeps) {
   const tempDir = await createTemporaryTsconfigDir(projectRoot, deps);
-  const configPath = join32(tempDir, "tsconfig.json");
+  const configPath = join33(tempDir, "tsconfig.json");
   const baseConfigFile = TSCONFIG_FILES[scope2];
-  const absoluteFiles = files.map((file) => isAbsolute7(file) ? file : join32(projectRoot, file));
+  const absoluteFiles = files.map((file) => isAbsolute8(file) ? file : join33(projectRoot, file));
   const tempConfig = {
-    extends: join32(projectRoot, baseConfigFile),
+    extends: join33(projectRoot, baseConfigFile),
     files: absoluteFiles,
     include: [],
     exclude: [],
@@ -14744,13 +15095,16 @@ async function createFileSpecificTsconfig(scope2, files, projectRoot, deps = def
 }
 async function createScopeFilteredTsconfig(scope2, projectRoot, scopeConfig, deps = defaultTypeScriptDeps) {
   const tempDir = await createTemporaryTsconfigDir(projectRoot, deps);
-  const configPath = join32(tempDir, "tsconfig.json");
+  const configPath = join33(tempDir, "tsconfig.json");
   const baseConfigFile = TSCONFIG_FILES[scope2];
-  const toProjectPathPattern = (pattern) => isAbsolute7(pattern) ? pattern : join32(projectRoot, pattern);
+  const toTemporaryConfigPathPattern = (pattern) => {
+    const absolutePattern = isAbsolute8(pattern) ? pattern : join33(projectRoot, pattern);
+    return relative8(tempDir, absolutePattern);
+  };
   const tempConfig = {
-    extends: join32(projectRoot, baseConfigFile),
-    include: scopeConfig.filePatterns.map(toProjectPathPattern),
-    exclude: scopeConfig.excludePatterns.map(toProjectPathPattern),
+    extends: join33(projectRoot, baseConfigFile),
+    include: scopeConfig.filePatterns.map(toTemporaryConfigPathPattern),
+    exclude: scopeConfig.excludePatterns.map(toTemporaryConfigPathPattern),
     compilerOptions: TEMPORARY_TSCONFIG_COMPILER_OPTIONS
   };
   deps.writeFileSync(configPath, JSON.stringify(tempConfig, null, 2));
@@ -14812,7 +15166,7 @@ async function validateTypeScript(context, options = {}) {
   );
 }
 function resolveProjectTscInvocation(projectRoot, deps, tscArgs) {
-  const tscBin = join32(projectRoot, "node_modules", ".bin", "tsc");
+  const tscBin = join33(projectRoot, "node_modules", ".bin", "tsc");
   const tool = deps.existsSync(tscBin) ? tscBin : "npx";
   return {
     tool,
@@ -14821,7 +15175,7 @@ function resolveProjectTscInvocation(projectRoot, deps, tscArgs) {
 }
 function runTypeScriptInvocation(projectRoot, invocation, runner, outputStreams, cleanup = () => {
 }) {
-  return new Promise((resolve10) => {
+  return new Promise((resolve11) => {
     const tscProcess = spawnManagedSubprocess(runner, invocation.tool, invocation.args, {
       cwd: projectRoot
     });
@@ -14829,14 +15183,14 @@ function runTypeScriptInvocation(projectRoot, invocation, runner, outputStreams,
     tscProcess.on(VALIDATION_SUBPROCESS_EVENTS.CLOSE, (code) => {
       cleanup();
       if (code === 0) {
-        resolve10({ success: true, skipped: false });
+        resolve11({ success: true, skipped: false });
       } else {
-        resolve10({ success: false, error: `TypeScript exited with code ${code}` });
+        resolve11({ success: false, error: `TypeScript exited with code ${code}` });
       }
     });
     tscProcess.on(VALIDATION_SUBPROCESS_EVENTS.ERROR, (error) => {
       cleanup();
-      resolve10({ success: false, error: error.message });
+      resolve11({ success: false, error: error.message });
     });
   });
 }
@@ -14869,16 +15223,17 @@ async function typescriptCommand(options) {
     };
   }
   const validationConfig = loaded.value[validationConfigDescriptor.section];
-  const validationPathFilter = validationPathFilterForTool(
-    validationConfig.paths,
-    VALIDATION_PATH_TOOL_SUBSECTIONS.TYPESCRIPT
-  );
-  const scopeConfig = applyValidationPathFilterToScope(
-    getTypeScriptScope(scope2, cwd),
-    validationPathFilter
-  );
-  const filteredFiles = files?.map((file) => toProjectRelativeValidationPath(cwd, file)).filter((file) => pathPassesValidationFilter(file, validationPathFilter));
-  if (scopeConfig.filteredByValidationPathNoMatches || files !== void 0 && files.length > 0 && filteredFiles?.length === 0) {
+  const scopeConfig = resolveTypeScriptValidationScope({
+    projectRoot: cwd,
+    scope: scope2,
+    paths: files,
+    validationPathFilter: validationPathFilterForTool(
+      validationConfig.paths,
+      VALIDATION_PATH_TOOL_SUBSECTIONS.TYPESCRIPT
+    ),
+    markExplicitPathsAsValidationFilter: true
+  });
+  if (scopeConfig.filteredByValidationPathNoMatches) {
     return {
       exitCode: 0,
       output: quiet ? "" : TYPESCRIPT_VALIDATION_MESSAGES.NO_VALIDATION_PATH_TARGETS,
@@ -14893,7 +15248,6 @@ async function typescriptCommand(options) {
   const result = await validateTypeScript({
     scope: scope2,
     projectRoot: cwd,
-    files: filteredFiles,
     scopeConfig
   });
   const durationMs = Date.now() - startTime;
@@ -14937,6 +15291,7 @@ async function runLiteralStage(context) {
   }
   return literalCommand({
     cwd: context.cwd,
+    scope: context.scope,
     files: context.files,
     quiet: context.quiet,
     json: context.json
@@ -15066,7 +15421,7 @@ async function allCommand(options) {
 // src/validation/literal/allowlist-existing.ts
 import { randomBytes } from "crypto";
 import { rename as rename4, writeFile as writeFile4 } from "fs/promises";
-import { dirname as dirname10, join as join33 } from "path";
+import { dirname as dirname10, join as join34 } from "path";
 var EXIT_OK = 0;
 var EXIT_ERROR = 1;
 var INCLUDE_FIELD = "include";
@@ -15086,7 +15441,7 @@ var productionWriter = {
   async write(filePath, content) {
     const dir = dirname10(filePath);
     const random = randomBytes(RANDOM_TOKEN_BYTES).toString("hex");
-    const tmpPath = join33(dir, `${TEMP_FILE_PREFIX}${random}${TEMP_FILE_SUFFIX}`);
+    const tmpPath = join34(dir, `${TEMP_FILE_PREFIX}${random}${TEMP_FILE_SUFFIX}`);
     await writeFile4(tmpPath, content, "utf8");
     await rename4(tmpPath, filePath);
   }
@@ -15206,6 +15561,10 @@ var validationCliDefinition = {
     longFlag: "--help",
     shortFlag: "-h"
   },
+  pathOperands: {
+    optionalVariadic: "[paths...]",
+    description: "Specific files/directories to validate"
+  },
   diagnostics: {
     unknownSubcommand: {
       messageLabel: "unknown subcommand",
@@ -15214,6 +15573,11 @@ var validationCliDefinition = {
     unknownLiteralProblemKind: {
       messageLabel: "unknown problem kind",
       exitCode: 1
+    },
+    invalidPathOperand: {
+      messageLabel: "invalid path operand",
+      reason: "escapes product directory",
+      exitCode: 1
     }
   }
 };
@@ -15269,7 +15633,50 @@ function emitValidationResult(result, io) {
   return io.exit(result.exitCode);
 }
 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");
+  const { pathOperands } = validationCliDefinition;
+  return cmd.argument(pathOperands.optionalVariadic, pathOperands.description).option("--scope <scope>", "Validation scope (full|production)", "full").option("--quiet", "Suppress progress output").option("--json", "Output results as JSON");
+}
+function normalizeProductPathOperand(productDir, effectiveInvocationDir, operand) {
+  const resolvedProductDir = canonicalExistingPath(resolve10(productDir));
+  const resolvedInvocationDir = canonicalExistingPath(resolve10(effectiveInvocationDir));
+  const absoluteOperand = canonicalExistingPath(resolve10(resolvedInvocationDir, operand));
+  const relativeOperand = relative9(resolvedProductDir, absoluteOperand);
+  if (relativeOperand === ".." || relativeOperand.startsWith(`..${sep3}`) || isAbsolute9(relativeOperand)) {
+    return void 0;
+  }
+  return relativeOperand.length > 0 ? relativeOperand.replaceAll("\\", "/") : ".";
+}
+function canonicalExistingPath(path7) {
+  return existsSync8(path7) ? realpathSync.native(path7) : path7;
+}
+function normalizePathOperands(productDir, effectiveInvocationDir, pathOperands) {
+  if (pathOperands.length === 0) return void 0;
+  const normalized = [];
+  for (const operand of pathOperands) {
+    const path7 = normalizeProductPathOperand(productDir, effectiveInvocationDir, operand);
+    if (path7 === void 0) return void 0;
+    normalized.push(path7);
+  }
+  return normalized;
+}
+function resolveValidationPaths(invocation, pathOperands) {
+  const context = invocation.resolveProductContext();
+  const files = normalizePathOperands(context.productDir, context.effectiveInvocationDir, pathOperands);
+  if (pathOperands.length > 0 && files === void 0) {
+    const { invalidPathOperand } = validationCliDefinition.diagnostics;
+    const invalidOperand = pathOperands.find(
+      (operand) => normalizeProductPathOperand(context.productDir, context.effectiveInvocationDir, operand) === void 0
+    );
+    invocation.io.writeStderr(
+      `spx ${validationCliDefinition.domain.commandName}: ${invalidPathOperand.messageLabel}: ${sanitizeCliArgument(invalidOperand)} (${invalidPathOperand.reason})
+`
+    );
+    invocation.io.exit(invalidPathOperand.exitCode);
+  }
+  return {
+    productDir: context.productDir,
+    files
+  };
 }
 function addValidationSubcommand(validationCmd, definition) {
   let subcommand = validationCmd.command(definition.commandName).description(definition.description);
@@ -15280,23 +15687,24 @@ function addValidationSubcommand(validationCmd, definition) {
 }
 function registerValidationCommands(validationCmd, invocation) {
   const { subcommands } = validationCliDefinition;
-  const productDir = () => invocation.resolveProductContext().productDir;
-  const tsCmd = addValidationSubcommand(validationCmd, subcommands.typescript).action(async (options) => {
+  const tsCmd = addValidationSubcommand(validationCmd, subcommands.typescript).action(async (pathOperands, options) => {
+    const paths = resolveValidationPaths(invocation, pathOperands);
     const result = await typescriptCommand({
-      cwd: productDir(),
+      cwd: paths.productDir,
       scope: options.scope,
-      files: options.files,
+      files: paths.files,
       quiet: options.quiet,
       json: options.json
     });
     emitValidationResult(result, invocation.io);
   });
   addCommonOptions(tsCmd);
-  const lintCmd = addValidationSubcommand(validationCmd, subcommands.lint).option("--fix", "Auto-fix issues").action(async (options) => {
+  const lintCmd = addValidationSubcommand(validationCmd, subcommands.lint).option("--fix", "Auto-fix issues").action(async (pathOperands, options) => {
+    const paths = resolveValidationPaths(invocation, pathOperands);
     const result = await lintCommand({
-      cwd: productDir(),
+      cwd: paths.productDir,
       scope: options.scope,
-      files: options.files,
+      files: paths.files,
       fix: options.fix,
       quiet: options.quiet,
       json: options.json
@@ -15304,22 +15712,24 @@ function registerValidationCommands(validationCmd, invocation) {
     emitValidationResult(result, invocation.io);
   });
   addCommonOptions(lintCmd);
-  const circularCmd = addValidationSubcommand(validationCmd, subcommands.circular).action(async (options) => {
+  const circularCmd = addValidationSubcommand(validationCmd, subcommands.circular).action(async (pathOperands, options) => {
+    const paths = resolveValidationPaths(invocation, pathOperands);
     const result = await circularCommand({
-      cwd: productDir(),
+      cwd: paths.productDir,
       scope: options.scope,
-      files: options.files,
+      files: paths.files,
       quiet: options.quiet,
       json: options.json
     });
     emitValidationResult(result, invocation.io);
   });
   addCommonOptions(circularCmd);
-  const knipCmd = addValidationSubcommand(validationCmd, subcommands.knip).action(async (options) => {
+  const knipCmd = addValidationSubcommand(validationCmd, subcommands.knip).action(async (pathOperands, options) => {
+    const paths = resolveValidationPaths(invocation, pathOperands);
     const result = await knipCommand({
-      cwd: productDir(),
+      cwd: paths.productDir,
       scope: options.scope,
-      files: options.files,
+      files: paths.files,
       quiet: options.quiet,
       json: options.json
     });
@@ -15335,9 +15745,10 @@ function registerValidationCommands(validationCmd, invocation) {
   ).option(literalValidationCliOptions.literals.flag, literalValidationCliOptions.literals.description).option(literalValidationCliOptions.verbose.flag, literalValidationCliOptions.verbose.description).addHelpText(
     "after",
     "\nEnabled for TypeScript projects by default. Set validation.literal.enabled=false\nin spx.config.* to skip during migration."
-  ).action(async (options) => {
+  ).action(async (pathOperands, options) => {
+    const paths = resolveValidationPaths(invocation, pathOperands);
     if (options.allowlistExisting) {
-      const result2 = await allowlistExisting({ productDir: productDir() });
+      const result2 = await allowlistExisting({ productDir: paths.productDir });
       emitValidationResult(result2, invocation.io);
     }
     let kind;
@@ -15353,8 +15764,9 @@ function registerValidationCommands(validationCmd, invocation) {
       }
     }
     const result = await literalCommand({
-      cwd: productDir(),
-      files: options.files,
+      cwd: paths.productDir,
+      scope: options.scope,
+      files: paths.files,
       kind,
       filesWithProblems: options.filesWithProblems,
       literals: options.literals,
@@ -15368,29 +15780,32 @@ function registerValidationCommands(validationCmd, invocation) {
   const markdownCmd = addValidationSubcommand(validationCmd, subcommands.markdown).addHelpText(
     "after",
     "\nValidates spx/ and docs/ by default. Nodes listed in spx/EXCLUDE are\nskipped \u2014 use this for declared-state nodes whose [test] links point\nto files that do not exist yet."
-  ).action(async (options) => {
+  ).action(async (pathOperands, options) => {
+    const paths = resolveValidationPaths(invocation, pathOperands);
     const result = await markdownCommand({
-      cwd: productDir(),
-      files: options.files,
+      cwd: paths.productDir,
+      files: paths.files,
       quiet: options.quiet
     });
     emitValidationResult(result, invocation.io);
   });
   addCommonOptions(markdownCmd);
-  const formatCmd = addValidationSubcommand(validationCmd, subcommands.format).action(async (options) => {
+  const formatCmd = addValidationSubcommand(validationCmd, subcommands.format).action(async (pathOperands, options) => {
+    const paths = resolveValidationPaths(invocation, pathOperands);
     const result = await formattingCommand({
-      cwd: productDir(),
-      files: options.files,
+      cwd: paths.productDir,
+      files: paths.files,
       quiet: options.quiet
     });
     emitValidationResult(result, invocation.io);
   });
   addCommonOptions(formatCmd);
-  const allCmd = addValidationSubcommand(validationCmd, subcommands.all).option("--fix", "Auto-fix ESLint issues").option(allValidationCliOptions.skipCircular.flag, allValidationCliOptions.skipCircular.description).option(allValidationCliOptions.skipLiteral.flag, allValidationCliOptions.skipLiteral.description).action(async (options) => {
+  const allCmd = addValidationSubcommand(validationCmd, subcommands.all).option("--fix", "Auto-fix ESLint issues").option(allValidationCliOptions.skipCircular.flag, allValidationCliOptions.skipCircular.description).option(allValidationCliOptions.skipLiteral.flag, allValidationCliOptions.skipLiteral.description).action(async (pathOperands, options) => {
+    const paths = resolveValidationPaths(invocation, pathOperands);
     const result = await allCommand({
-      cwd: productDir(),
+      cwd: paths.productDir,
       scope: options.scope,
-      files: options.files,
+      files: paths.files,
       fix: options.fix,
       skipCircular: options.skipCircular,
       skipLiteral: options.skipLiteral,
@@ -15430,7 +15845,7 @@ var validationDomain = {
 };
 
 // src/commands/verification-context/cli.ts
-import { isAbsolute as isAbsolute8, win32 } from "path";
+import { isAbsolute as isAbsolute10, win32 } from "path";
 
 // src/domains/verification-context/context.ts
 var VERIFICATION_CONTEXT_SCHEMA_VERSION = "verification-context.v1";
@@ -15467,7 +15882,7 @@ function createVerificationContextDocument(payload) {
 import { dirname as dirname11 } from "path";
 
 // src/domains/verification-context/path.ts
-import { join as join34 } from "path";
+import { join as join35 } from "path";
 var VERIFICATION_CONTEXT_STATE_DOMAIN = VERIFICATION_CONTEXT_PERSISTENCE.domain;
 var VERIFICATION_CONTEXT_STATE_PATH = {
   CONTEXTS_DIR: "contexts",
@@ -15488,7 +15903,7 @@ function verificationContextFilePath(scope2) {
   if (!contextsDir.ok) return contextsDir;
   const digest = validateScopeToken(scope2.digest);
   if (!digest.ok) return digest;
-  return { ok: true, value: join34(contextsDir.value, verificationContextFileName(digest.value)) };
+  return { ok: true, value: join35(contextsDir.value, verificationContextFileName(digest.value)) };
 }
 
 // src/commands/verification-context/runtime.ts
@@ -15581,7 +15996,7 @@ function normalizeFileSubjectPath(path7) {
     VERIFICATION_CONTEXT_FILE_SUBJECT_PATH.SEPARATOR.CANONICAL
   );
   const segments = normalized.split(VERIFICATION_CONTEXT_FILE_SUBJECT_PATH.SEPARATOR.CANONICAL);
-  if (isAbsolute8(path7) || win32.isAbsolute(path7) || windowsRoot.length > 0 || segments.includes(VERIFICATION_CONTEXT_FILE_SUBJECT_PATH.PARENT_DIRECTORY.SEGMENT)) {
+  if (isAbsolute10(path7) || win32.isAbsolute(path7) || windowsRoot.length > 0 || segments.includes(VERIFICATION_CONTEXT_FILE_SUBJECT_PATH.PARENT_DIRECTORY.SEGMENT)) {
     return void 0;
   }
   return normalized;
@@ -15689,8 +16104,11 @@ var WORKTREE_STATUS_RENDER = {
   FREE: "-",
   RUNNING_PID_PREFIX: "PID "
 };
+var WORKTREE_STATUS_ERROR = {
+  ALL_WITH_EXPLICIT_TARGETS: "worktree status --all cannot be combined with explicit worktree operands"
+};
 async function statusCommand2(options) {
-  const multiTargetRequest = options.worktrees !== void 0 && options.worktrees.length > 1;
+  const multiTargetRequest = options.all === true || options.worktrees !== void 0 && options.worktrees.length > 1;
   const targets = await resolveStatusTargets(options);
   if (!targets.ok) return targets;
   const records = [];
@@ -15708,6 +16126,12 @@ async function statusCommand2(options) {
 }
 async function resolveStatusTargets(options) {
   const requested = options.worktrees;
+  if (options.all === true) {
+    if (requested !== void 0 && requested.length > 0) {
+      return { ok: false, error: WORKTREE_STATUS_ERROR.ALL_WITH_EXPLICIT_TARGETS };
+    }
+    return resolveAllTargetWorktrees(options);
+  }
   if (requested === void 0 || requested.length === 0) {
     const target = await resolveTargetWorktree(options);
     if (!target.ok) return target;
@@ -15745,11 +16169,11 @@ function renderTextStatus(record6) {
 }
 
 // src/lib/worktree-path-info.ts
-import { stat as stat4 } from "fs/promises";
+import { stat as stat5 } from "fs/promises";
 var defaultWorktreePathInfo = {
   isExistingNonDirectory: async (path7) => {
     try {
-      const pathStats = await stat4(path7);
+      const pathStats = await stat5(path7);
       return !pathStats.isDirectory();
     } catch {
       return false;
@@ -15765,6 +16189,7 @@ var WORKTREE_CLI = {
   RELEASE: "release",
   WORKTREE_ARGUMENT: "[worktrees...]",
   SESSION_ID_FLAG: "--session-id",
+  ALL_FLAG: "--all",
   FORMAT_FLAG: "--format",
   WORKTREES_DIR_FLAG: "--worktrees-dir"
 };
@@ -15803,21 +16228,24 @@ function registerWorktreeCommands(worktreeCmd, invocation) {
     });
     if (!result.ok) handleError3(invocation, result.error);
   });
-  worktreeCmd.command(`${WORKTREE_CLI.STATUS} ${WORKTREE_CLI.WORKTREE_ARGUMENT}`).description("Report a worktree's occupancy (running | free)").option(`${WORKTREE_CLI.FORMAT_FLAG} <format>`, "Output format (text|json)", WORKTREE_STATUS_FORMAT.TEXT).option(`${WORKTREE_CLI.WORKTREES_DIR_FLAG} <path>`, "Explicit .spx/worktrees directory").action(async (worktrees, options) => {
-    const result = await statusCommand2({
-      cwd: effectiveInvocationDir(),
-      fs: defaultOccupancyFileSystem,
-      gitDeps: defaultGitDependencies,
-      worktrees,
-      format: options.format,
-      pathInfo: defaultWorktreePathInfo,
-      processTable: defaultProcessTable,
-      worktreesDir: options.worktreesDir,
-      onWarning: (warning) => writeInvocationWarning4(invocation, warning)
-    });
-    if (!result.ok) handleError3(invocation, result.error);
-    writeOutput4(invocation, result.value);
-  });
+  worktreeCmd.command(`${WORKTREE_CLI.STATUS} ${WORKTREE_CLI.WORKTREE_ARGUMENT}`).description("Report a worktree's occupancy (running | free)").option(WORKTREE_CLI.ALL_FLAG, "Report every git-observed worktree").option(`${WORKTREE_CLI.FORMAT_FLAG} <format>`, "Output format (text|json)", WORKTREE_STATUS_FORMAT.TEXT).option(`${WORKTREE_CLI.WORKTREES_DIR_FLAG} <path>`, "Explicit .spx/worktrees directory").action(
+    async (worktrees, options) => {
+      const result = await statusCommand2({
+        cwd: effectiveInvocationDir(),
+        fs: defaultOccupancyFileSystem,
+        gitDeps: defaultGitDependencies,
+        worktrees,
+        all: options.all,
+        format: options.format,
+        pathInfo: defaultWorktreePathInfo,
+        processTable: defaultProcessTable,
+        worktreesDir: options.worktreesDir,
+        onWarning: (warning) => writeInvocationWarning4(invocation, warning)
+      });
+      if (!result.ok) handleError3(invocation, result.error);
+      writeOutput4(invocation, result.value);
+    }
+  );
   worktreeCmd.command(WORKTREE_CLI.RELEASE).description("Release the running worktree's occupancy claim").option(`${WORKTREE_CLI.WORKTREES_DIR_FLAG} <path>`, "Explicit .spx/worktrees directory").action(async (options) => {
     const result = await releaseCommand2({
       cwd: effectiveInvocationDir(),