@outcomeeng/spx 0.6.1 → 0.6.3

package/dist/cli.js

@@ -49,39 +49,45 @@ async function findSettingsFiles(root, visited = /* @__PURE__ */ new Set()) {
   }
   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;
+    return await findSettingsFilesInDirectory(normalizedRoot, visited);
   } 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;
+    throw discoveryError(normalizedRoot, error);
   }
 }
+async function findSettingsFilesInDirectory(normalizedRoot, visited) {
+  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) {
+    results.push(...await settingsFilesForEntry(normalizedRoot, entry, visited));
+  }
+  return results;
+}
+async function settingsFilesForEntry(normalizedRoot, entry, visited) {
+  if (!entry.isDirectory()) return [];
+  const fullPath = path.join(normalizedRoot, entry.name);
+  if (entry.name === ".claude") {
+    const settingsPath = path.join(fullPath, "settings.local.json");
+    return await isValidSettingsFile(settingsPath) ? [settingsPath] : [];
+  }
+  return findSettingsFiles(fullPath, visited);
+}
+function discoveryError(normalizedRoot, error) {
+  if (!(error instanceof Error)) return new Error(unknownErrorMessage(error));
+  if (error.message.includes("ENOENT")) return new Error(`Directory not found: ${normalizedRoot}`);
+  if (error.message.includes("EACCES")) return new Error(`Permission denied: ${normalizedRoot}`);
+  return new Error(`Failed to search directory "${normalizedRoot}": ${error.message}`);
+}
+function unknownErrorMessage(error) {
+  if (typeof error === "string") return error;
+  if (typeof error === "number" || typeof error === "boolean" || typeof error === "bigint") return error.toString();
+  if (typeof error === "symbol") return error.description ?? "Symbol()";
+  if (error === void 0) return "undefined";
+  return Object.prototype.toString.call(error);
+}
 async function isValidSettingsFile(filePath) {
   try {
     await fs.access(filePath, fs.constants.R_OK);
@@ -801,6 +807,7 @@ function toErrorMessage(error) {
 
 // src/lib/claude/permissions/parser.ts
 import fs2 from "fs/promises";
+var PERMISSION_PATTERN = /^([^(]+)\((.+)\)$/;
 async function parseSettingsFile(filePath) {
   try {
     const content = await fs2.readFile(filePath, "utf-8");
@@ -814,7 +821,7 @@ async function parseSettingsFile(filePath) {
   }
 }
 function parsePermission(raw, category) {
-  const match = raw.match(/^([^(]+)\((.+)\)$/);
+  const match = PERMISSION_PATTERN.exec(raw);
   if (!match) {
     throw new Error(`Malformed permission string: "${raw}"`);
   }
@@ -1095,88 +1102,91 @@ async function createBackup(settingsPath) {
 
 // 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("");
+  return [
+    ...headerLines(),
+    ...filesSummaryLines(result),
+    ...permissionLines(result, totalAdded),
+    ...subsumptionLines(result),
+    ...conflictLines(result),
+    ...backupLines(result),
+    ...summaryLines(result),
+    ...finalStatusLines(result, previewOnly, globalSettingsPath, outputFile)
+  ].join("\n");
+}
+function headerLines() {
+  return ["Scanning for Claude Code settings files...", ""];
+}
+function filesSummaryLines(result) {
+  const lines = [`Found ${result.filesScanned} settings files`, `  Processed: ${result.filesProcessed}`];
+  if (result.filesSkipped > 0) lines.push(`  Skipped: ${result.filesSkipped} (no permissions)`);
+  return [...lines, ""];
+}
+function permissionLines(result, totalAdded) {
+  if (totalAdded === 0) return ["No new permissions to add (all permissions already in global settings)", ""];
+  return [
+    `Permissions to add: ${totalAdded}`,
+    ...permissionCategoryLines("allow", result.added.allow),
+    ...permissionCategoryLines("deny", result.added.deny),
+    ...permissionCategoryLines("ask", result.added.ask),
+    ""
+  ];
+}
+function permissionCategoryLines(label, permissions) {
+  if (permissions.length === 0) return [];
+  return ["", `  ${label}:`, ...permissions.map((permission) => `    + ${permission}`)];
+}
+function subsumptionLines(result) {
+  if (result.subsumed.length === 0) return [];
+  return [
+    `Subsumed permissions removed: ${result.subsumed.length}`,
+    "  (narrower permissions replaced by broader ones)",
+    ...result.subsumed.map((permission) => `    - ${permission}`),
+    ""
+  ];
+}
+function conflictLines(result) {
+  if (result.conflictsResolved === 0) return [];
+  return [`Conflicts resolved: ${result.conflictsResolved}`, "  (permissions moved from allow to deny)", ""];
+}
+function backupLines(result) {
+  return result.backupPath ? [`Backup created: ${result.backupPath}`, ""] : [];
+}
+function summaryLines(result) {
+  return [
+    "Summary:",
+    `  Files scanned: ${result.filesScanned}`,
+    `  Permissions added: ${result.added.allow.length} allow, ${result.added.deny.length} deny, ${result.added.ask.length} ask`,
+    ...optionalSummaryLines(result),
+    ""
+  ];
+}
+function optionalSummaryLines(result) {
+  return [
+    ...result.subsumed.length > 0 ? [`  Subsumed removed: ${result.subsumed.length}`] : [],
+    ...result.conflictsResolved > 0 ? [`  Conflicts resolved: ${result.conflictsResolved}`] : []
+  ];
+}
+function finalStatusLines(result, previewOnly, globalSettingsPath, outputFile) {
   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 [
+      "\u2139\uFE0F  Preview mode: No changes written",
+      "",
+      "To apply changes:",
+      "  \u2022 Modify global settings: spx claude settings consolidate --write",
+      "  \u2022 Write to file: spx claude settings consolidate --output-file /path/to/file"
+    ];
   }
-  return lines.join("\n");
+  if (outputFile) {
+    return [
+      `\u2713 Settings written to: ${result.outputPath || outputFile}`,
+      "",
+      "To apply to your global settings:",
+      `  \u2022 Review the file, then copy to: ${globalSettingsPath || "~/.claude/settings.json"}`,
+      "  \u2022 Or run: spx claude settings consolidate --write"
+    ];
+  }
+  return [`\u2713 Global settings updated: ${globalSettingsPath || "~/.claude/settings.json"}`];
 }
 
 // src/lib/claude/settings/writer.ts
@@ -1403,7 +1413,7 @@ var COMPACT_MARKER = {
   FOUNDATION: "SPEC_TREE_FOUNDATION",
   CONTEXT: "SPEC_TREE_CONTEXT",
   TARGET_ATTRIBUTE: "target",
-  ESCAPED_TARGET_QUOTE: '\\"',
+  ESCAPED_TARGET_QUOTE: String.raw`\"`,
   UNESCAPED_TARGET_QUOTE: '"'
 };
 var COMPACT_ERROR = {
@@ -1510,8 +1520,8 @@ function readTargetPath(value, startIndex) {
   return value.slice(startIndex, endIndex);
 }
 function isTargetPathCharacter(character) {
-  const code = character.charCodeAt(0);
-  return code >= 48 && code <= 57 || code >= 65 && code <= 90 || code >= 97 && code <= 122 || character === "." || character === "_" || character === "-" || character === "/";
+  const code = character.codePointAt(0);
+  return code !== void 0 && (code >= 48 && code <= 57 || code >= 65 && code <= 90 || code >= 97 && code <= 122 || character === "." || character === "_" || character === "-" || character === "/");
 }
 
 // src/commands/compact/retrieve.ts
@@ -1598,6 +1608,18 @@ import { join as join5 } from "path";
 import { parse as parseToml, stringify as stringifyToml } from "smol-toml";
 import { parse as parseYaml, parseDocument as parseYamlDocument, stringify as stringifyYaml } from "yaml";
 
+// src/lib/error-message.ts
+function toMessage(error) {
+  if (error instanceof Error) return error.message;
+  if (typeof error === "string") return error;
+  const fallback = `[${typeof error}]`;
+  try {
+    return JSON.stringify(error) ?? fallback;
+  } catch {
+    return fallback;
+  }
+}
+
 // src/domains/agent-environment/config.ts
 var AGENT_ENVIRONMENT_SECTION = "agentEnvironment";
 var AGENT_RUNTIME = {
@@ -1794,15 +1816,15 @@ function validateRuntimes(raw) {
   }
   return { ok: true, value: runtimes };
 }
-function validateRuntimeConfig(path7, raw, defaults4) {
+function validateRuntimeConfig(path7, raw, defaults5) {
   if (!isRecord(raw)) return { ok: false, error: `${path7} must be an object` };
   const unknown = rejectUnknownFields(path7, raw, AGENT_ENVIRONMENT_RUNTIME_CONFIG_ALLOWED_FIELDS);
   if (!unknown.ok) return unknown;
   const enabledRaw = raw[AGENT_ENVIRONMENT_CONFIG_FIELDS.ENABLED];
-  if (enabledRaw === void 0) return { ok: true, value: defaults4 };
+  if (enabledRaw === void 0) return { ok: true, value: defaults5 };
   const enabled = validateBoolean(`${path7}.${AGENT_ENVIRONMENT_CONFIG_FIELDS.ENABLED}`, enabledRaw);
   if (!enabled.ok) return enabled;
-  return { ok: true, value: { ...defaults4, enabled: enabled.value } };
+  return { ok: true, value: { ...defaults5, enabled: enabled.value } };
 }
 function validatePluginBootstrap(raw) {
   const sectionPath = `${AGENT_ENVIRONMENT_SECTION}.${AGENT_ENVIRONMENT_CONFIG_FIELDS.PLUGIN_BOOTSTRAP}`;
@@ -1866,8 +1888,8 @@ function validatePluginBootstrap(raw) {
     }
   };
 }
-function validateEntryArray(path7, raw, validateEntry2, defaults4) {
-  if (raw === void 0) return { ok: true, value: defaults4 };
+function validateEntryArray(path7, raw, validateEntry2, defaults5) {
+  if (raw === void 0) return { ok: true, value: defaults5 };
   if (!Array.isArray(raw)) return { ok: false, error: `${path7} must be an array` };
   const entries = [];
   for (const [index, entry] of raw.entries()) {
@@ -2050,6 +2072,82 @@ var agentEnvironmentConfigDescriptor = {
   validate
 };
 
+// src/domains/diagnose/facts.ts
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isNonEmptyString(value) {
+  return typeof value === "string" && value.length > 0;
+}
+function isNonEmptyStringArray(value) {
+  return Array.isArray(value) && value.length > 0 && value.every(isNonEmptyString);
+}
+function validateMarketplaceIdentity(value, field) {
+  if (!isRecord2(value) || !isNonEmptyString(value.name) || !isNonEmptyString(value.source)) {
+    return { ok: false, error: `${field} must carry a non-empty \`name\` and \`source\`` };
+  }
+  return { ok: true, value: { name: value.name, source: value.source } };
+}
+
+// src/domains/diagnose/config.ts
+var DIAGNOSE_SECTION = "diagnose";
+var DIAGNOSE_CONFIG_FIELDS = {
+  SPX_FLOOR: "spxFloor",
+  MARKETPLACE: "marketplace",
+  EXPECTED_PLUGINS: "expectedPlugins",
+  CHECKS: "checks"
+};
+var defaults = {};
+function validate2(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return { ok: false, error: `${DIAGNOSE_SECTION} section must be an object` };
+  }
+  const candidate = value;
+  const resolved = {};
+  const spxFloor = candidate[DIAGNOSE_CONFIG_FIELDS.SPX_FLOOR];
+  if (spxFloor !== void 0) {
+    if (!isNonEmptyString(spxFloor)) {
+      return { ok: false, error: `${DIAGNOSE_SECTION}.${DIAGNOSE_CONFIG_FIELDS.SPX_FLOOR} must be a non-empty string` };
+    }
+    resolved.spxFloor = spxFloor;
+  }
+  const marketplace = candidate[DIAGNOSE_CONFIG_FIELDS.MARKETPLACE];
+  if (marketplace !== void 0) {
+    const result = validateMarketplaceIdentity(
+      marketplace,
+      `${DIAGNOSE_SECTION}.${DIAGNOSE_CONFIG_FIELDS.MARKETPLACE}`
+    );
+    if (!result.ok) return result;
+    resolved.marketplace = result.value;
+  }
+  const expectedPlugins = candidate[DIAGNOSE_CONFIG_FIELDS.EXPECTED_PLUGINS];
+  if (expectedPlugins !== void 0) {
+    if (!isNonEmptyStringArray(expectedPlugins)) {
+      return {
+        ok: false,
+        error: `${DIAGNOSE_SECTION}.${DIAGNOSE_CONFIG_FIELDS.EXPECTED_PLUGINS} must be a non-empty array of non-empty strings`
+      };
+    }
+    resolved.expectedPlugins = expectedPlugins;
+  }
+  const checks = candidate[DIAGNOSE_CONFIG_FIELDS.CHECKS];
+  if (checks !== void 0) {
+    if (!isNonEmptyStringArray(checks)) {
+      return {
+        ok: false,
+        error: `${DIAGNOSE_SECTION}.${DIAGNOSE_CONFIG_FIELDS.CHECKS} must be a non-empty array of non-empty strings`
+      };
+    }
+    resolved.checks = checks;
+  }
+  return { ok: true, value: resolved };
+}
+var diagnoseConfigDescriptor = {
+  section: DIAGNOSE_SECTION,
+  defaults,
+  validate: validate2
+};
+
 // src/lib/spec-tree/config.ts
 var SPEC_TREE_KIND_CATEGORY_VALUES = {
   NODE: "node",
@@ -2229,7 +2327,7 @@ var SPEC_TREE_NODE_STATE = {
 };
 var SPEC_TREE_SECTION = SPEC_TREE_CONFIG.SECTION;
 function isKind(value) {
-  return Object.prototype.hasOwnProperty.call(KIND_REGISTRY, value);
+  return Object.hasOwn(KIND_REGISTRY, value);
 }
 function buildDefaults() {
   return { kinds: { ...KIND_REGISTRY } };
@@ -2238,7 +2336,7 @@ function buildConfigFromKindNames(kindNames) {
   const entries = kindNames.map((kind) => [kind, KIND_REGISTRY[kind]]);
   return { kinds: Object.fromEntries(entries) };
 }
-function validate2(value) {
+function validate3(value) {
   if (typeof value !== "object" || value === null) {
     return { ok: false, error: `${SPEC_TREE_SECTION} section must be an object` };
   }
@@ -2337,7 +2435,7 @@ function validateKindDefinitionMap(kindEntries) {
 var specTreeConfigDescriptor = {
   section: SPEC_TREE_SECTION,
   defaults: buildDefaults(),
-  validate: validate2
+  validate: validate3
 };
 
 // src/lib/file-inclusion/adapters/eslint.ts
@@ -2513,11 +2611,11 @@ var DEFAULT_SCOPE_CONFIG = {
 var DEFAULT_TOOLS_CONFIG = Object.fromEntries(
   Object.entries(TOOL_DEFAULT_FLAGS).map(([name, flag]) => [name, { ignoreFlag: flag }])
 );
-var defaults = {
+var defaults2 = {
   scope: DEFAULT_SCOPE_CONFIG,
   tools: DEFAULT_TOOLS_CONFIG
 };
-function isRecord2(value) {
+function isRecord3(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function validateStringField(section, field, value) {
@@ -2540,7 +2638,7 @@ function rejectUnknownFields2(section, value, allowed) {
   return { ok: true, value: void 0 };
 }
 function validateScope(raw) {
-  if (!isRecord2(raw)) {
+  if (!isRecord3(raw)) {
     return {
       ok: false,
       error: `${FILE_INCLUSION_SECTION}.${FILE_INCLUSION_CONFIG_FIELDS.SCOPE} must be an object`
@@ -2597,7 +2695,7 @@ function validateScope(raw) {
   };
 }
 function validateTools(raw) {
-  if (!isRecord2(raw)) {
+  if (!isRecord3(raw)) {
     return {
       ok: false,
       error: `${FILE_INCLUSION_SECTION}.${FILE_INCLUSION_CONFIG_FIELDS.TOOLS} must be an object`
@@ -2612,7 +2710,7 @@ function validateTools(raw) {
         error: `${FILE_INCLUSION_SECTION}.${FILE_INCLUSION_CONFIG_FIELDS.TOOLS}.${toolName} is not a recognized tool`
       };
     }
-    if (!isRecord2(adapterRaw)) {
+    if (!isRecord3(adapterRaw)) {
       return {
         ok: false,
         error: `${FILE_INCLUSION_SECTION}.${FILE_INCLUSION_CONFIG_FIELDS.TOOLS}.${toolName} must be an object`
@@ -2632,7 +2730,7 @@ function validateTools(raw) {
   }
   return { ok: true, value: tools };
 }
-function validate3(value) {
+function validate4(value) {
   if (typeof value !== "object" || value === null || Array.isArray(value)) {
     return { ok: false, error: `${FILE_INCLUSION_SECTION} section must be an object` };
   }
@@ -2659,8 +2757,8 @@ function validate3(value) {
 }
 var fileInclusionConfigDescriptor = {
   section: FILE_INCLUSION_SECTION,
-  defaults,
-  validate: validate3
+  defaults: defaults2,
+  validate: validate4
 };
 
 // src/lib/precommit/config.ts
@@ -2669,7 +2767,7 @@ var PRECOMMIT_DEFAULTS = {
   sourceDirs: ["src/"],
   testPattern: ".test.ts"
 };
-function validate4(value) {
+function validate5(value) {
   if (typeof value !== "object" || value === null || Array.isArray(value)) {
     return { ok: false, error: `${PRECOMMIT_SECTION} section must be an object` };
   }
@@ -2699,7 +2797,7 @@ function validate4(value) {
 var precommitConfigDescriptor = {
   section: PRECOMMIT_SECTION,
   defaults: PRECOMMIT_DEFAULTS,
-  validate: validate4
+  validate: validate5
 };
 
 // src/config/primitives/path-filter.ts
@@ -2736,7 +2834,11 @@ function validatePathFilterConfig(raw, path7) {
 }
 var PATH_SEGMENT_SEPARATOR = "/";
 function normalizePathPrefix(value) {
-  return value.replace(/\/+$/, "");
+  let end = value.length;
+  while (end > 0 && value[end - 1] === PATH_SEGMENT_SEPARATOR) {
+    end -= 1;
+  }
+  return value.slice(0, end);
 }
 function pathMatchesPrefix(path7, prefix) {
   const normalizedPath = normalizePathPrefix(path7);
@@ -2760,7 +2862,7 @@ var TESTING_CONFIG_FIELDS = {
   PASSING_SCOPE: "passingScope"
 };
 var DEFAULT_PASSING_SCOPE = resolveDefaultPassingScope();
-var defaults2 = {
+var defaults3 = {
   passingScope: DEFAULT_PASSING_SCOPE
 };
 function resolveDefaultPassingScope() {
@@ -2773,14 +2875,14 @@ function resolveDefaultPassingScope() {
   }
   return result.value;
 }
-function validate5(value) {
+function validate6(value) {
   if (typeof value !== "object" || value === null || Array.isArray(value)) {
     return { ok: false, error: `${TESTING_SECTION} section must be an object` };
   }
   const candidate = value;
   const passingScopeRaw = candidate[TESTING_CONFIG_FIELDS.PASSING_SCOPE];
   if (passingScopeRaw === void 0) {
-    return { ok: true, value: defaults2 };
+    return { ok: true, value: defaults3 };
   }
   const passingScopeResult = validatePathFilterConfig(
     passingScopeRaw,
@@ -2796,8 +2898,8 @@ function validate5(value) {
 }
 var testingConfigDescriptor = {
   section: TESTING_SECTION,
-  defaults: defaults2,
-  validate: validate5
+  defaults: defaults3,
+  validate: validate6
 };
 
 // src/validation/literal/config.ts
@@ -2806,6 +2908,10 @@ var DEFAULT_MIN_STRING_LENGTH = 4;
 var DEFAULT_MIN_NUMBER_DIGITS = 4;
 var LEGACY_LITERAL_ALLOWLIST_FIELD = "allowlist";
 var LEGACY_LITERAL_ALLOWLIST_ERROR = "validation.literal.values.allowlist is no longer valid; move its contents up one level to validation.literal.values.{presets,include,exclude}";
+var LITERAL_STRING_LIST_FIELDS = {
+  INCLUDE: "include",
+  EXCLUDE: "exclude"
+};
 var PRESET_NAMES = {
   WEB: "web"
 };
@@ -2854,7 +2960,10 @@ var LITERAL_DEFAULTS = {
   minStringLength: DEFAULT_MIN_STRING_LENGTH,
   minNumberDigits: DEFAULT_MIN_NUMBER_DIGITS
 };
-function validate6(value) {
+function isNonNegativeInteger(value) {
+  return typeof value === "number" && Number.isInteger(value) && value >= 0;
+}
+function validate7(value) {
   if (typeof value !== "object" || value === null || Array.isArray(value)) {
     return { ok: false, error: `${LITERAL_SECTION} section must be an object` };
   }
@@ -2862,34 +2971,21 @@ function validate6(value) {
   if (candidate[LEGACY_LITERAL_ALLOWLIST_FIELD] !== void 0) {
     return { ok: false, error: LEGACY_LITERAL_ALLOWLIST_ERROR };
   }
-  const presets = candidate["presets"];
-  if (presets !== void 0) {
-    if (!Array.isArray(presets) || !presets.every((x) => typeof x === "string")) {
-      return { ok: false, error: `${LITERAL_SECTION}.presets must be an array of strings` };
-    }
-    for (const id of presets) {
-      if (!PRESET_REGISTRY.has(id)) {
-        return { ok: false, error: `${LITERAL_SECTION}.presets: unrecognized preset "${id}"` };
-      }
-    }
-  }
-  const include = candidate["include"];
-  if (include !== void 0 && (!Array.isArray(include) || !include.every((x) => typeof x === "string"))) {
-    return { ok: false, error: `${LITERAL_SECTION}.include must be an array of strings` };
-  }
-  const exclude = candidate["exclude"];
-  if (exclude !== void 0 && (!Array.isArray(exclude) || !exclude.every((x) => typeof x === "string"))) {
-    return { ok: false, error: `${LITERAL_SECTION}.exclude must be an array of strings` };
-  }
+  const presets = readPresetList(candidate);
+  if (!presets.ok) return presets;
+  const include = readStringList(candidate, LITERAL_STRING_LIST_FIELDS.INCLUDE);
+  if (!include.ok) return include;
+  const exclude = readStringList(candidate, LITERAL_STRING_LIST_FIELDS.EXCLUDE);
+  if (!exclude.ok) return exclude;
   const minStringLength = candidate["minStringLength"] ?? LITERAL_DEFAULTS.minStringLength;
-  if (typeof minStringLength !== "number" || !Number.isInteger(minStringLength) || minStringLength < 0) {
+  if (!isNonNegativeInteger(minStringLength)) {
     return {
       ok: false,
       error: `${LITERAL_SECTION}.minStringLength must be a non-negative integer`
     };
   }
   const minNumberDigits = candidate["minNumberDigits"] ?? LITERAL_DEFAULTS.minNumberDigits;
-  if (typeof minNumberDigits !== "number" || !Number.isInteger(minNumberDigits) || minNumberDigits < 0) {
+  if (!isNonNegativeInteger(minNumberDigits)) {
     return {
       ok: false,
       error: `${LITERAL_SECTION}.minNumberDigits must be a non-negative integer`
@@ -2898,18 +2994,40 @@ function validate6(value) {
   return {
     ok: true,
     value: {
-      presets,
-      include,
-      exclude,
+      presets: presets.value,
+      include: include.value,
+      exclude: exclude.value,
       minStringLength,
       minNumberDigits
     }
   };
 }
+function readPresetList(candidate) {
+  const presets = candidate["presets"];
+  if (presets === void 0) return { ok: true, value: void 0 };
+  if (!isStringArray(presets)) {
+    return { ok: false, error: `${LITERAL_SECTION}.presets must be an array of strings` };
+  }
+  for (const id of presets) {
+    if (!PRESET_REGISTRY.has(id)) {
+      return { ok: false, error: `${LITERAL_SECTION}.presets: unrecognized preset "${id}"` };
+    }
+  }
+  return { ok: true, value: presets };
+}
+function readStringList(candidate, field) {
+  const value = candidate[field];
+  if (value === void 0) return { ok: true, value: void 0 };
+  if (!isStringArray(value)) return { ok: false, error: `${LITERAL_SECTION}.${field} must be an array of strings` };
+  return { ok: true, value };
+}
+function isStringArray(value) {
+  return Array.isArray(value) && value.every((item) => typeof item === "string");
+}
 var literalConfigDescriptor = {
   section: LITERAL_SECTION,
   defaults: LITERAL_DEFAULTS,
-  validate: validate6
+  validate: validate7
 };
 
 // src/validation/config/descriptor.ts
@@ -2925,9 +3043,10 @@ var VALIDATION_PATH_TOOL_SUBSECTIONS = {
   CIRCULAR: "circular",
   KNIP: "knip",
   MARKDOWN: "markdown",
-  LITERAL: "literal"
+  LITERAL: "literal",
+  FORMATTING: "formatting"
 };
-var defaults3 = {
+var defaults4 = {
   paths: {},
   literal: {
     enabled: true,
@@ -2967,7 +3086,7 @@ function validateLiteral(raw) {
     };
   }
   const candidate = raw;
-  const enabledRaw = candidate[VALIDATION_ENABLED_FIELD] ?? defaults3.literal.enabled;
+  const enabledRaw = candidate[VALIDATION_ENABLED_FIELD] ?? defaults4.literal.enabled;
   if (typeof enabledRaw !== "boolean") {
     return {
       ok: false,
@@ -2992,7 +3111,7 @@ function validateKnip(raw) {
     };
   }
   const candidate = raw;
-  const enabledRaw = candidate[VALIDATION_ENABLED_FIELD] ?? defaults3.knip.enabled;
+  const enabledRaw = candidate[VALIDATION_ENABLED_FIELD] ?? defaults4.knip.enabled;
   if (typeof enabledRaw !== "boolean") {
     return {
       ok: false,
@@ -3001,7 +3120,7 @@ function validateKnip(raw) {
   }
   return { ok: true, value: { enabled: enabledRaw } };
 }
-function validate7(value) {
+function validate8(value) {
   if (typeof value !== "object" || value === null || Array.isArray(value)) {
     return { ok: false, error: `${VALIDATION_SECTION} section must be an object` };
   }
@@ -3019,8 +3138,8 @@ function validate7(value) {
 }
 var validationConfigDescriptor = {
   section: VALIDATION_SECTION,
-  defaults: defaults3,
-  validate: validate7
+  defaults: defaults4,
+  validate: validate8
 };
 
 // src/config/registry.ts
@@ -3030,7 +3149,8 @@ var productionRegistry = [
   testingConfigDescriptor,
   fileInclusionConfigDescriptor,
   precommitConfigDescriptor,
-  agentEnvironmentConfigDescriptor
+  agentEnvironmentConfigDescriptor,
+  diagnoseConfigDescriptor
 ];
 
 // src/config/descriptor-digest.ts
@@ -3328,7 +3448,7 @@ function setNested(target, path7, value) {
       cursor = fresh;
     }
   }
-  cursor[path7[path7.length - 1]] = value;
+  cursor[path7.at(-1)] = value;
 }
 function validateParsedSections(filename, parsed) {
   if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
@@ -3339,9 +3459,6 @@ function validateParsedSections(filename, parsed) {
 function isFileNotFound(error) {
   return error instanceof Error && "code" in error && error.code === "ENOENT";
 }
-function toMessage(error) {
-  return error instanceof Error ? error.message : String(error);
-}
 
 // src/commands/config/defaults.ts
 function defaultsCommand(options, deps) {
@@ -3576,12 +3693,6 @@ var CHECK_NAME = {
   SESSION_STORE: "session-store",
   MARKETPLACE_INSTALL: "marketplace-install"
 };
-function isRecord3(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function isNonEmptyString(value) {
-  return typeof value === "string" && value.length > 0;
-}
 function validateChecks(raw, available) {
   if (!Array.isArray(raw) || raw.length === 0) {
     return { ok: false, error: "manifest `checks` must be a non-empty array of check names" };
@@ -3595,12 +3706,6 @@ function validateChecks(raw, available) {
   }
   return { ok: true, value: raw };
 }
-function validateMarketplace2(raw) {
-  if (!isRecord3(raw) || !isNonEmptyString(raw.name) || !isNonEmptyString(raw.source)) {
-    return { ok: false, error: "manifest `marketplace` must carry a non-empty `name` and `source`" };
-  }
-  return { ok: true, value: { name: raw.name, source: raw.source } };
-}
 function parseManifest(rawJson, availableChecks) {
   let parsed;
   try {
@@ -3608,7 +3713,7 @@ function parseManifest(rawJson, availableChecks) {
   } catch (error) {
     return { ok: false, error: `manifest is not valid JSON: ${error.message}` };
   }
-  if (!isRecord3(parsed)) {
+  if (!isRecord2(parsed)) {
     return { ok: false, error: "manifest must be a JSON object" };
   }
   const checks = validateChecks(parsed.checks, new Set(availableChecks));
@@ -3621,9 +3726,9 @@ function parseManifest(rawJson, availableChecks) {
     manifest.spxFloor = parsed.spx_floor;
   }
   if (checks.value.includes(CHECK_NAME.MARKETPLACE_INSTALL)) {
-    const marketplace = validateMarketplace2(parsed.marketplace);
+    const marketplace = validateMarketplaceIdentity(parsed.marketplace, "manifest `marketplace`");
     if (!marketplace.ok) return marketplace;
-    if (!Array.isArray(parsed.expected_plugins) || !parsed.expected_plugins.every(isNonEmptyString)) {
+    if (!isNonEmptyStringArray(parsed.expected_plugins)) {
       return { ok: false, error: "manifest selects `marketplace-install` but carries no `expected_plugins`" };
     }
     manifest.marketplace = marketplace.value;
@@ -3738,21 +3843,70 @@ function renderReport(report2, format2, options) {
   return format2 === DIAGNOSE_FORMAT.JSON ? renderReportJson(report2) : renderReportText(report2, options);
 }
 
+// src/domains/diagnose/resolve.ts
+var CHECK_NAMES = new Set(Object.values(CHECK_NAME));
+function isCheckName(value) {
+  return CHECK_NAMES.has(value);
+}
+function resolveDiagnoseFacts(options) {
+  if (options.manifest !== void 0) {
+    return { ok: true, value: options.manifest };
+  }
+  const { config, availableChecks } = options;
+  const configuredChecks = config.checks;
+  let checks;
+  if (configuredChecks === void 0) {
+    checks = availableChecks;
+  } else {
+    const available = new Set(availableChecks);
+    const unavailable = configuredChecks.filter((name) => !isCheckName(name) || !available.has(name));
+    if (unavailable.length > 0) {
+      return {
+        ok: false,
+        error: `diagnose config \`checks\` names checks not available in this build: ${unavailable.join(", ")}`
+      };
+    }
+    checks = configuredChecks.filter(isCheckName);
+  }
+  return {
+    ok: true,
+    value: {
+      checks,
+      spxFloor: config.spxFloor,
+      marketplace: config.marketplace,
+      expectedPlugins: config.expectedPlugins
+    }
+  };
+}
+
 // src/commands/diagnose/index.ts
-async function diagnoseCommand(options) {
+async function resolveDiagnoseConfig(productDir) {
+  const loaded = await resolveConfig(productDir, [diagnoseConfigDescriptor]);
+  if (!loaded.ok) return loaded;
+  return { ok: true, value: loaded.value[diagnoseConfigDescriptor.section] };
+}
+async function readManifest(fs8, manifestPath, availableChecks) {
   let raw;
   try {
-    raw = await options.fs.readFile(options.manifestPath);
+    raw = await fs8.readFile(manifestPath);
   } catch (error) {
-    return {
-      ok: false,
-      error: `cannot read diagnose manifest at ${options.manifestPath}: ${error.message}`
-    };
+    return { ok: false, error: `cannot read diagnose manifest at ${manifestPath}: ${error.message}` };
   }
+  return parseManifest(raw, availableChecks);
+}
+async function diagnoseCommand(options) {
   const availableChecks = Object.keys(options.registry);
-  const manifest = parseManifest(raw, availableChecks);
-  if (!manifest.ok) return manifest;
-  const report2 = await runDiagnose(manifest.value, options.registry);
+  const manifest = options.manifestPath === void 0 ? void 0 : await readManifest(options.fs, options.manifestPath, availableChecks);
+  if (manifest !== void 0 && !manifest.ok) return manifest;
+  const config = manifest === void 0 ? await resolveDiagnoseConfig(options.productDir) : { ok: true, value: {} };
+  if (!config.ok) return config;
+  const resolved = resolveDiagnoseFacts({
+    manifest: manifest?.value,
+    config: config.value,
+    availableChecks
+  });
+  if (!resolved.ok) return resolved;
+  const report2 = await runDiagnose(resolved.value, options.registry);
   if (!report2.ok) return report2;
   return {
     ok: true,
@@ -3857,9 +4011,8 @@ function nonEmptyString(value) {
 // src/domains/worktree/occupancy-store.ts
 import { join as join6 } from "path";
 var OCCUPANCY_STATUS = {
-  UNCLAIMED: "unclaimed",
-  OCCUPIED: "occupied",
-  STALE: "stale"
+  FREE: "free",
+  RUNNING: "running"
 };
 var OCCUPANCY_CLAIM = {
   FILE_EXTENSION: ".claim",
@@ -3889,13 +4042,13 @@ function claimTempFilePath(claimPath, writeToken) {
   return { ok: true, value: `${claimPath}.${validated.value}${OCCUPANCY_CLAIM.TEMP_EXTENSION}` };
 }
 function classifyOccupancy(claim, probe) {
-  if (claim === void 0) return OCCUPANCY_STATUS.UNCLAIMED;
-  if (claim.host !== probe.currentHost()) return OCCUPANCY_STATUS.STALE;
-  if (!probe.isAlive(claim.pid)) return OCCUPANCY_STATUS.STALE;
+  if (claim === void 0) return OCCUPANCY_STATUS.FREE;
+  if (claim.host !== probe.currentHost()) return OCCUPANCY_STATUS.FREE;
+  if (!probe.isAlive(claim.pid)) return OCCUPANCY_STATUS.FREE;
+  if (claim.startedAt === unreadableStartedAt(claim.pid)) return OCCUPANCY_STATUS.RUNNING;
   const liveStartTime = probe.startTimeOf(claim.pid);
-  if (claim.startedAt === unreadableStartedAt(claim.pid)) return OCCUPANCY_STATUS.OCCUPIED;
-  if (liveStartTime !== void 0 && liveStartTime !== claim.startedAt) return OCCUPANCY_STATUS.STALE;
-  return OCCUPANCY_STATUS.OCCUPIED;
+  if (liveStartTime !== void 0 && liveStartTime !== claim.startedAt) return OCCUPANCY_STATUS.FREE;
+  return OCCUPANCY_STATUS.RUNNING;
 }
 function unreadableStartedAt(pid) {
   return `${OCCUPANCY_CLAIM.UNREADABLE_STARTED_AT_PREFIX}${pid}`;
@@ -3937,11 +4090,6 @@ async function removeClaim(worktreesDir, name, options) {
     return { ok: false, error: formatOccupancyError(OCCUPANCY_ERROR.CLAIM_REMOVE_FAILED, toErrorMessage2(error)) };
   }
 }
-async function readOccupancy(worktreesDir, name, probe, options) {
-  const claimResult = await readClaim(worktreesDir, name, options);
-  if (!claimResult.ok) return claimResult;
-  return { ok: true, value: classifyOccupancy(claimResult.value, probe) };
-}
 function serializeClaim(record6) {
   return JSON.stringify({
     sessionId: record6.sessionId,
@@ -3969,7 +4117,10 @@ function formatOccupancyError(code, detail) {
   return `${code}${ERROR_DETAIL_SEPARATOR2}${detail}`;
 }
 function toErrorMessage2(error) {
-  return error instanceof Error ? error.message : String(error);
+  if (error instanceof Error) return error.message;
+  if (typeof error === "string") return error;
+  if (typeof error === "number" || typeof error === "bigint" || typeof error === "boolean") return error.toString();
+  return JSON.stringify(error) ?? "unknown error";
 }
 
 // src/domains/worktree/worktree-name.ts
@@ -4119,27 +4270,25 @@ var defaultWorktreePoolProbe = {
       errored: true,
       bareRepository: false,
       linkedWorktrees: false,
-      staleClaim: false
+      running: 0,
+      free: 0
     };
+    const root = await detectGitCommonDirProductRoot();
     const facts = await gatherGitFacts();
-    if (!facts?.worktreeListRead) return errored;
+    if (!root.isGitRepo || !facts?.worktreeListRead) return errored;
     const bareRepository = facts.commonDirIsBare;
     const paths = facts.worktreeRoots;
     const linkedWorktrees = !bareRepository && paths.length > 1;
-    const spx = resolveSpx();
-    if (spx === null) return errored;
-    let staleClaim = false;
+    const worktreesDir = worktreesScopeDir(root.productDir);
+    let running = 0;
+    let free = 0;
     for (const path7 of paths) {
-      const status = await runCapture(spx, ["worktree", "status", path7, "--format", "json"]);
-      if (!status.ok) return errored;
-      const occupancy = worktreeStatusOf(status.stdout);
-      if (occupancy === null) return errored;
-      if (occupancy === OCCUPANCY_STATUS.STALE) {
-        staleClaim = true;
-        break;
-      }
+      const claim = await readClaim(worktreesDir, worktreeClaimName(path7), { fs: defaultOccupancyFileSystem });
+      if (!claim.ok) return errored;
+      if (classifyOccupancy(claim.value, defaultProcessTable) === OCCUPANCY_STATUS.RUNNING) running += 1;
+      else free += 1;
     }
-    return { errored: false, bareRepository, linkedWorktrees, staleClaim };
+    return { errored: false, bareRepository, linkedWorktrees, running, free };
   }
 };
 var defaultSessionEnvironmentProbe = {
@@ -4148,22 +4297,21 @@ var defaultSessionEnvironmentProbe = {
     const sessionIdentity = resolveAgentSessionId(process.env) !== void 0;
     const spx = resolveSpx();
     if (spx === null) {
-      return { errored: true, hookPresent, sessionIdentity, worktreeClaimed: false, roundTripStale: false };
+      return { errored: true, hookPresent, sessionIdentity, worktreeClaimed: false };
     }
     const status = await runCapture(spx, ["worktree", "status", "--format", "json"]);
     if (!status.ok) {
-      return { errored: true, hookPresent, sessionIdentity, worktreeClaimed: false, roundTripStale: false };
+      return { errored: true, hookPresent, sessionIdentity, worktreeClaimed: false };
     }
     const occupancy = worktreeStatusOf(status.stdout);
     if (occupancy === null) {
-      return { errored: true, hookPresent, sessionIdentity, worktreeClaimed: false, roundTripStale: false };
+      return { errored: true, hookPresent, sessionIdentity, worktreeClaimed: false };
     }
     return {
       errored: false,
       hookPresent,
       sessionIdentity,
-      worktreeClaimed: occupancy === OCCUPANCY_STATUS.OCCUPIED,
-      roundTripStale: occupancy === OCCUPANCY_STATUS.STALE
+      worktreeClaimed: occupancy === OCCUPANCY_STATUS.RUNNING
     };
   }
 };
@@ -4177,7 +4325,7 @@ async function claimedSessionIds() {
   for (const path7 of facts.worktreeRoots) {
     const claim = await readClaim(worktreesDir, worktreeClaimName(path7), { fs: defaultOccupancyFileSystem });
     if (!claim.ok || claim.value === void 0) continue;
-    if (classifyOccupancy(claim.value, defaultProcessTable) === OCCUPANCY_STATUS.OCCUPIED) {
+    if (classifyOccupancy(claim.value, defaultProcessTable) === OCCUPANCY_STATUS.RUNNING) {
       sessionIds.add(normalizeAgentSessionToken(claim.value.sessionId));
     }
   }
@@ -4392,8 +4540,7 @@ function record2(verdict, bucket, reading) {
     readings: {
       hook: String(reading.hookPresent),
       identity: String(reading.sessionIdentity),
-      claimed: String(reading.worktreeClaimed),
-      stale: String(reading.roundTripStale)
+      claimed: String(reading.worktreeClaimed)
     },
     remediation: REMEDIATION2[verdict]
   };
@@ -4402,7 +4549,7 @@ function classifySessionEnvironment(reading) {
   if (!reading.hookPresent) {
     return record2(SESSION_ENVIRONMENT_VERDICT.NOT_APPLICABLE, VERDICT_BUCKET.NOT_APPLICABLE, reading);
   }
-  if (reading.errored || reading.roundTripStale) {
+  if (reading.errored) {
     return record2(SESSION_ENVIRONMENT_VERDICT.UNKNOWN, VERDICT_BUCKET.UNKNOWN, reading);
   }
   if (reading.sessionIdentity && reading.worktreeClaimed) {
@@ -4428,7 +4575,7 @@ var SESSION_STORE_VERDICT = {
 };
 var REMEDIATION3 = {
   [SESSION_STORE_VERDICT.CONSISTENT]: "Session store is consistent; no action needed.",
-  [SESSION_STORE_VERDICT.ORPHANED_CLAIMS]: "Release or reclaim doing sessions whose backing worktree is stale or absent (spx session release).",
+  [SESSION_STORE_VERDICT.ORPHANED_CLAIMS]: "Release or reclaim doing sessions whose backing worktree reads free or is absent (spx session release).",
   [SESSION_STORE_VERDICT.UNKNOWN]: "Re-run diagnose; if it persists, inspect spx session list and spx worktree status."
 };
 function record3(verdict, bucket, reading) {
@@ -4458,6 +4605,7 @@ function sessionStoreRunner(probe) {
 // src/domains/diagnose/checks/spx-reachability.ts
 var SPX_REACHABILITY_VERDICT = {
   REACHABLE: "reachable",
+  PRESENT: "present",
   BELOW_FLOOR: "below-floor",
   UNREACHABLE: "unreachable",
   UNKNOWN: "unknown"
@@ -4508,9 +4656,10 @@ function meetsFloor(version2, floor) {
 }
 var REMEDIATION4 = {
   [SPX_REACHABILITY_VERDICT.REACHABLE]: "spx is on PATH at or above the required floor; no action needed.",
+  [SPX_REACHABILITY_VERDICT.PRESENT]: "spx is on PATH; no version floor is configured to compare against, so only presence is reported.",
   [SPX_REACHABILITY_VERDICT.BELOW_FLOOR]: "Update spx to at least the required floor (pnpm add -g @outcomeeng/spx).",
   [SPX_REACHABILITY_VERDICT.UNREACHABLE]: "Install spx and ensure it resolves on PATH (pnpm add -g @outcomeeng/spx).",
-  [SPX_REACHABILITY_VERDICT.UNKNOWN]: "Re-run diagnose; if it persists, verify the manifest carries a valid spx_floor, that spx is on PATH, and that spx --version reports a semver version."
+  [SPX_REACHABILITY_VERDICT.UNKNOWN]: "Re-run diagnose; if it persists, verify the configured or manifest-supplied spx_floor is a valid semver, that spx is on PATH, and that spx --version reports a semver version."
 };
 function record4(verdict, bucket, reading, floor) {
   return {
@@ -4526,12 +4675,15 @@ function record4(verdict, bucket, reading, floor) {
   };
 }
 function classifySpxReachability(reading, floor) {
-  if (reading.errored || floor === void 0) {
+  if (reading.errored) {
     return record4(SPX_REACHABILITY_VERDICT.UNKNOWN, VERDICT_BUCKET.UNKNOWN, reading, floor);
   }
   if (reading.resolvedPath === null) {
     return record4(SPX_REACHABILITY_VERDICT.UNREACHABLE, VERDICT_BUCKET.BROKEN, reading, floor);
   }
+  if (floor === void 0) {
+    return record4(SPX_REACHABILITY_VERDICT.PRESENT, VERDICT_BUCKET.HEALTHY, reading, floor);
+  }
   if (reading.version === null) {
     return record4(SPX_REACHABILITY_VERDICT.UNKNOWN, VERDICT_BUCKET.UNKNOWN, reading, floor);
   }
@@ -4548,13 +4700,11 @@ function spxReachabilityRunner(probe) {
 // src/domains/diagnose/checks/worktree-pool.ts
 var WORKTREE_POOL_VERDICT = {
   COMPLIANT: "compliant",
-  STALE_CLAIMS: "stale-claims",
   NON_COMPLIANT: "non-compliant",
   UNKNOWN: "unknown"
 };
 var REMEDIATION5 = {
   [WORKTREE_POOL_VERDICT.COMPLIANT]: "Worktree layout is compliant; no action needed.",
-  [WORKTREE_POOL_VERDICT.STALE_CLAIMS]: "Release stale worktree claims (spx worktree release) or remove dead worktrees.",
   [WORKTREE_POOL_VERDICT.NON_COMPLIANT]: "Linked worktrees require a bare-repository pool; convert the layout or remove the linked worktrees.",
   [WORKTREE_POOL_VERDICT.UNKNOWN]: "Re-run diagnose; if it persists, inspect git worktree list and spx worktree status."
 };
@@ -4566,7 +4716,8 @@ function record5(verdict, bucket, reading) {
     readings: {
       bare: String(reading.bareRepository),
       linked: String(reading.linkedWorktrees),
-      stale: String(reading.staleClaim)
+      running: String(reading.running),
+      free: String(reading.free)
     },
     remediation: REMEDIATION5[verdict]
   };
@@ -4578,9 +4729,6 @@ function classifyWorktreePool(reading) {
   if (!reading.bareRepository && reading.linkedWorktrees) {
     return record5(WORKTREE_POOL_VERDICT.NON_COMPLIANT, VERDICT_BUCKET.BROKEN, reading);
   }
-  if (reading.staleClaim) {
-    return record5(WORKTREE_POOL_VERDICT.STALE_CLAIMS, VERDICT_BUCKET.DEGRADED, reading);
-  }
   return record5(WORKTREE_POOL_VERDICT.COMPLIANT, VERDICT_BUCKET.HEALTHY, reading);
 }
 function worktreePoolRunner(probe) {
@@ -4598,7 +4746,7 @@ var DEL_CHAR_CODE = 127;
 var HEX_RADIX = 16;
 var HEX_PAD = 2;
 function formatHexEscape(code) {
-  return `\\x${code.toString(HEX_RADIX).padStart(HEX_PAD, "0")}`;
+  return String.raw`\x${code.toString(HEX_RADIX).padStart(HEX_PAD, "0")}`;
 }
 function nonStringSentinel(type) {
   return `<non-string:${type}>`;
@@ -4639,7 +4787,7 @@ var DIAGNOSE_CLI = {
   COLOR_FLAG: "--color",
   NO_COLOR_FLAG: "--no-color"
 };
-var DIAGNOSE_DOMAIN_DESCRIPTION = "Run deterministic environment-diagnostics checks from a declarative manifest";
+var DIAGNOSE_DOMAIN_DESCRIPTION = "Run deterministic environment-diagnostics checks, resolving facts from spx.config or a --manifest";
 var DEFAULT_REGISTRY = {
   [CHECK_NAME.SPX_REACHABILITY]: spxReachabilityRunner(defaultSpxReachabilityProbe),
   [CHECK_NAME.SESSION_ENVIRONMENT]: sessionEnvironmentRunner(defaultSessionEnvironmentProbe),
@@ -4655,11 +4803,15 @@ var diagnoseDomain = {
   name: DIAGNOSE_CLI.COMMAND,
   description: DIAGNOSE_DOMAIN_DESCRIPTION,
   register: (program2) => {
-    program2.command(DIAGNOSE_CLI.COMMAND).description(DIAGNOSE_DOMAIN_DESCRIPTION).requiredOption(`${DIAGNOSE_CLI.MANIFEST_FLAG} <path>`, "Path to the declarative diagnose manifest").addOption(
+    program2.command(DIAGNOSE_CLI.COMMAND).description(DIAGNOSE_DOMAIN_DESCRIPTION).option(
+      `${DIAGNOSE_CLI.MANIFEST_FLAG} <path>`,
+      "Path to a declarative diagnose manifest that fully instruments the diagnosis"
+    ).addOption(
       new Option(`${DIAGNOSE_CLI.FORMAT_FLAG} <format>`, "Output format").choices([DIAGNOSE_FORMAT.TEXT, DIAGNOSE_FORMAT.JSON]).default(DIAGNOSE_FORMAT.TEXT)
     ).addOption(new Option(`${DIAGNOSE_CLI.COLOR_FLAG}`, "Force colored output")).addOption(new Option(`${DIAGNOSE_CLI.NO_COLOR_FLAG}`, "Disable colored output")).action(async (options) => {
       const result = await diagnoseCommand({
         manifestPath: options.manifest,
+        productDir: process.cwd(),
         format: options.format,
         color: resolveColorChoice({
           flag: options.color,
@@ -4682,7 +4834,7 @@ import { appendFile as nodeAppendFile } from "fs/promises";
 // src/domains/worktree/controlling-process.ts
 var CONTROLLING_PID_ENV = "SPX_WORKTREE_CONTROLLING_PID";
 var AGENT_RUNTIME_NAMES = ["claude", "codex"];
-var AGENT_COMMAND_PATTERN = new RegExp(`\\b(?:${AGENT_RUNTIME_NAMES.join("|")})\\b`, "i");
+var AGENT_COMMAND_PATTERN = new RegExp(String.raw`\b(?:${AGENT_RUNTIME_NAMES.join("|")})\b`, "i");
 var CONTROLLING_PROCESS_ERROR = {
   UNRESOLVED: "worktree controlling process could not be resolved"
 };
@@ -5159,6 +5311,84 @@ function createJournal(backend, identity) {
   };
 }
 
+// src/lib/github-snapshot-sink/gh-api-runner.ts
+import { execa as execa5 } from "execa";
+var GH_API = {
+  executable: "gh"
+};
+var runGhApi = async (args, options) => {
+  const result = await execa5(GH_API.executable, [...args], {
+    ...options?.input === void 0 ? {} : { input: options.input }
+  });
+  return { stdout: typeof result.stdout === "string" ? result.stdout : "" };
+};
+
+// src/lib/github-snapshot-sink/pull-request-comment-client.ts
+var GITHUB_API_ERROR = {
+  SURFACE_UNSUPPORTED: "the pull-request comment client supports only the pull-request comment surface"
+};
+var GITHUB_API = {
+  apiCommand: "api",
+  fieldFlag: "-f",
+  methodFlag: "-X",
+  paginateFlag: "--paginate",
+  slurpFlag: "--slurp",
+  postMethod: "POST",
+  patchMethod: "PATCH",
+  bodyField: "body"
+};
+function githubCommentMarkerTag(marker) {
+  return `<!-- ${marker} -->`;
+}
+function issueCommentsPath(repository, pullNumber) {
+  return `repos/${repository}/issues/${pullNumber}/comments`;
+}
+function issueCommentPath(repository, commentId) {
+  return `repos/${repository}/issues/comments/${commentId}`;
+}
+function createGithubPullRequestCommentClient(options) {
+  const { run } = options;
+  return {
+    async upsertPullRequestComment({ pullNumber, marker, body }) {
+      const markedBody = `${body}
+${githubCommentMarkerTag(marker)}`;
+      const listed = await run([
+        GITHUB_API.apiCommand,
+        issueCommentsPath(options.repository, pullNumber),
+        GITHUB_API.paginateFlag,
+        GITHUB_API.slurpFlag
+      ]);
+      const comments = JSON.parse(listed.stdout).flat();
+      const existing = comments.find((comment) => comment.body.includes(githubCommentMarkerTag(marker)));
+      if (existing === void 0) {
+        await run([
+          GITHUB_API.apiCommand,
+          issueCommentsPath(options.repository, pullNumber),
+          GITHUB_API.methodFlag,
+          GITHUB_API.postMethod,
+          GITHUB_API.fieldFlag,
+          `${GITHUB_API.bodyField}=${markedBody}`
+        ]);
+        return;
+      }
+      await run([
+        GITHUB_API.apiCommand,
+        issueCommentPath(options.repository, existing.id),
+        GITHUB_API.methodFlag,
+        GITHUB_API.patchMethod,
+        GITHUB_API.fieldFlag,
+        `${GITHUB_API.bodyField}=${markedBody}`
+      ]);
+    },
+    uploadActionsArtifact() {
+      return Promise.reject(new Error(GITHUB_API_ERROR.SURFACE_UNSUPPORTED));
+    },
+    saveActionsCache() {
+      return Promise.reject(new Error(GITHUB_API_ERROR.SURFACE_UNSUPPORTED));
+    }
+  };
+}
+
 // src/lib/github-snapshot-sink/index.ts
 var SNAPSHOT_SURFACE_KIND = {
   PULL_REQUEST_COMMENT: "pull-request-comment",
@@ -5369,7 +5599,7 @@ async function appendJournalEvent(ref, input, sink, options = {}) {
   try {
     event = await bound.value.journal.append(input);
   } catch (error) {
-    return { ok: false, error: `${JOURNAL_RUNTIME_ERROR.APPEND_FAILED}: ${toMessage2(error)}` };
+    return { ok: false, error: `${JOURNAL_RUNTIME_ERROR.APPEND_FAILED}: ${toMessage(error)}` };
   }
   try {
     await sink.emit(event);
@@ -5383,7 +5613,7 @@ async function readJournalEvents(ref, fromCursor, options = {}) {
   try {
     return { ok: true, value: await bound.value.journal.read(fromCursor) };
   } catch (error) {
-    return { ok: false, error: `${JOURNAL_RUNTIME_ERROR.READ_FAILED}: ${toMessage2(error)}` };
+    return { ok: false, error: `${JOURNAL_RUNTIME_ERROR.READ_FAILED}: ${toMessage(error)}` };
   }
 }
 async function sealJournalRun(ref, options = {}) {
@@ -5393,7 +5623,7 @@ async function sealJournalRun(ref, options = {}) {
     await bound.value.journal.seal();
     return { ok: true, value: void 0 };
   } catch (error) {
-    return { ok: false, error: `${JOURNAL_RUNTIME_ERROR.SEAL_FAILED}: ${toMessage2(error)}` };
+    return { ok: false, error: `${JOURNAL_RUNTIME_ERROR.SEAL_FAILED}: ${toMessage(error)}` };
   }
 }
 async function renderJournalRun(ref, projection, options = {}) {
@@ -5402,12 +5632,9 @@ async function renderJournalRun(ref, projection, options = {}) {
   try {
     return { ok: true, value: await bound.value.journal.render(projection) };
   } catch (error) {
-    return { ok: false, error: `${JOURNAL_RUNTIME_ERROR.RENDER_FAILED}: ${toMessage2(error)}` };
+    return { ok: false, error: `${JOURNAL_RUNTIME_ERROR.RENDER_FAILED}: ${toMessage(error)}` };
   }
 }
-function toMessage2(error) {
-  return error instanceof Error ? error.message : String(error);
-}
 
 // src/commands/journal/cli.ts
 var JOURNAL_CLI_EXIT_CODE = {
@@ -5600,80 +5827,6 @@ async function journalRenderCommand(scope2, deps = {}) {
   return okResult(JSON.stringify(rendered.value));
 }
 
-// src/commands/journal/github-client.ts
-import { execa as execa5 } from "execa";
-var GITHUB_CLI_ERROR = {
-  SURFACE_UNSUPPORTED: "the pull-request comment client supports only the pull-request comment surface"
-};
-var GITHUB_CLI = {
-  executable: "gh",
-  apiCommand: "api",
-  fieldFlag: "-f",
-  methodFlag: "-X",
-  paginateFlag: "--paginate",
-  slurpFlag: "--slurp",
-  postMethod: "POST",
-  patchMethod: "PATCH",
-  bodyField: "body"
-};
-var defaultGhRunner = async (args, options) => {
-  const result = await execa5(GITHUB_CLI.executable, [...args], {
-    ...options?.input === void 0 ? {} : { input: options.input }
-  });
-  return { stdout: typeof result.stdout === "string" ? result.stdout : "" };
-};
-function githubCommentMarkerTag(marker) {
-  return `<!-- ${marker} -->`;
-}
-function issueCommentsPath(repository, pullNumber) {
-  return `repos/${repository}/issues/${pullNumber}/comments`;
-}
-function issueCommentPath(repository, commentId) {
-  return `repos/${repository}/issues/comments/${commentId}`;
-}
-function createGithubPrCommentClient(options) {
-  const run = options.run ?? defaultGhRunner;
-  return {
-    async upsertPullRequestComment({ pullNumber, marker, body }) {
-      const markedBody = `${body}
-${githubCommentMarkerTag(marker)}`;
-      const listed = await run([
-        GITHUB_CLI.apiCommand,
-        issueCommentsPath(options.repository, pullNumber),
-        GITHUB_CLI.paginateFlag,
-        GITHUB_CLI.slurpFlag
-      ]);
-      const comments = JSON.parse(listed.stdout).flat();
-      const existing = comments.find((comment) => comment.body.includes(githubCommentMarkerTag(marker)));
-      if (existing === void 0) {
-        await run([
-          GITHUB_CLI.apiCommand,
-          issueCommentsPath(options.repository, pullNumber),
-          GITHUB_CLI.methodFlag,
-          GITHUB_CLI.postMethod,
-          GITHUB_CLI.fieldFlag,
-          `${GITHUB_CLI.bodyField}=${markedBody}`
-        ]);
-        return;
-      }
-      await run([
-        GITHUB_CLI.apiCommand,
-        issueCommentPath(options.repository, existing.id),
-        GITHUB_CLI.methodFlag,
-        GITHUB_CLI.patchMethod,
-        GITHUB_CLI.fieldFlag,
-        `${GITHUB_CLI.bodyField}=${markedBody}`
-      ]);
-    },
-    uploadActionsArtifact() {
-      return Promise.reject(new Error(GITHUB_CLI_ERROR.SURFACE_UNSUPPORTED));
-    },
-    saveActionsCache() {
-      return Promise.reject(new Error(GITHUB_CLI_ERROR.SURFACE_UNSUPPORTED));
-    }
-  };
-}
-
 // src/lib/process-lifecycle/exit-codes.ts
 var SIGINT_EXIT_CODE = 130;
 var SIGTERM_EXIT_CODE = 143;
@@ -5913,7 +6066,7 @@ function streamBinding() {
   const repository = process.env[JOURNAL_CLI_ENV.GITHUB_REPOSITORY] ?? "";
   return {
     localSink: stdoutStreamSink(),
-    githubClient: createGithubPrCommentClient({ repository }),
+    githubClient: createGithubPullRequestCommentClient({ repository, run: runGhApi }),
     githubRepository: repository
   };
 }
@@ -6157,9 +6310,7 @@ var NoSessionsAvailableError = class extends SessionError {
 var SessionLegacyFrontmatterInputError = class extends SessionError {
   constructor() {
     super(
-      `Invalid handoff input: stdin opens with the YAML-frontmatter delimiter \`---\`. Use the JSON-prefix wire format: a single JSON object holding caller-supplied fields followed by the body bytes verbatim. Example:
-
-  printf '%s\\n' '{"priority":"high","goal":"...","next_step":"..."}' '# Body' | spx session handoff`
+      "Invalid handoff input: stdin opens with the YAML-frontmatter delimiter `---`. Use the JSON-prefix wire format: a single JSON object holding caller-supplied fields followed by the body bytes verbatim. Example:\n\n" + String.raw`  printf '%s\n' '{"priority":"high","goal":"...","next_step":"..."}' '# Body' ` + "| spx session handoff"
     );
     this.name = "SessionLegacyFrontmatterInputError";
   }
@@ -6582,7 +6733,7 @@ function resolveSessionPaths(id, config = DEFAULT_SESSION_CONFIG) {
 }
 function formatShowOutput(content, options) {
   const metadata = parseSessionMetadata(content);
-  const headerLines = [
+  const headerLines2 = [
     `${SESSION_SHOW_LABEL.STATUS}: ${options.status}`,
     `${SESSION_SHOW_LABEL.PRIORITY}: ${metadata.priority}`,
     `${SESSION_SHOW_LABEL.GIT_REF}: ${metadata.git_ref}`,
@@ -6591,7 +6742,7 @@ function formatShowOutput(content, options) {
     `${SESSION_SHOW_LABEL.CREATED}: ${metadata.created_at ?? ""}`,
     `${SESSION_SHOW_LABEL.AGENT_SESSION}: ${metadata.agent_session_id ?? ""}`
   ];
-  const header = headerLines.join("\n");
+  const header = headerLines2.join("\n");
   const separator = "\n" + SESSION_SHOW_SEPARATOR_CHAR.repeat(SESSION_SHOW_SEPARATOR_WIDTH) + "\n\n";
   return header + separator + content;
 }
@@ -7351,13 +7502,13 @@ Workflow:
   4. archive  - Move session to archive
   5. delete   - Remove session permanently
 `;
-var HANDOFF_FRONTMATTER_HELP = `
+var HANDOFF_FRONTMATTER_HELP = String.raw`
 Usage:
   Pipe a JSON header followed by the body bytes to stdin.
 
   The header is a single JSON object holding caller-supplied structured fields.
   A single LF or CRLF after the header is consumed as a separator. The body
-  is the remaining bytes verbatim \u2014 no YAML, no escape rules, no ambiguity
+  is the remaining bytes verbatim — no YAML, no escape rules, no ambiguity
   from leading characters like '#' or '---'.
 
 JSON Header Fields:
@@ -7380,11 +7531,11 @@ Output Tags (for automation):
   <SESSION_FILE>/path/to/file</SESSION_FILE>   Absolute path to created file
 
 Canonical Invocation:
-  printf '%s\\n' \\
-    '{"priority":"high","goal":"Fix login","next_step":"Run validation","specs":[],"files":[]}' \\
-    '# Fix login' \\
-    '' \\
-    'Body text \u2014 # symbols, --- delimiters, and code fences are literal.' \\
+  printf '%s\n' \
+    '{"priority":"high","goal":"Fix login","next_step":"Run validation","specs":[],"files":[]}' \
+    '# Fix login' \
+    '' \
+    'Body text — # symbols, --- delimiters, and code fences are literal.' \
     | spx session handoff
 `;
 var PICKUP_SELECTION_HELP = `
@@ -9081,92 +9232,111 @@ async function runNodeCommand(options, deps) {
   return { dispatch, runFile, recorded };
 }
 
-// src/commands/spec/node-outcome-resolver.ts
-var PATH_SEPARATOR = "/";
-function createNodeOutcomeResolver(deps) {
-  let evidence;
-  const currentInputsByCoveredPaths = /* @__PURE__ */ new Map();
-  const sharedEvidence = () => evidence ??= loadResolverEvidence(deps);
-  const refreshEvidence = () => {
-    evidence = loadResolverEvidence(deps);
-  };
-  const currentInputsFor = (coveredPaths) => {
-    const cacheKey = coveredPathCollectionKey(coveredPaths);
-    const cached = currentInputsByCoveredPaths.get(cacheKey);
-    if (cached !== void 0) {
-      return cached;
-    }
-    const current = currentStalenessInputs(deps.productDir, coveredPaths, deps);
-    currentInputsByCoveredPaths.set(cacheKey, current);
-    return current;
-  };
-  return async (nodeId) => {
-    const { discoveredTestPaths, terminalRuns } = await sharedEvidence();
-    const nodePath = `${SPEC_TREE_CONFIG.ROOT_DIRECTORY}${PATH_SEPARATOR}${nodeId}`;
-    const nodeTestPaths = filterNodeTestPaths(discoveredTestPaths, nodePath);
-    const usable = await usableRecordedOutcome(discoveredTestPaths, terminalRuns, nodeTestPaths, currentInputsFor);
-    if (usable !== void 0) {
-      return usable;
-    }
-    const { dispatch, recorded } = await runNodeCommand({ productDir: deps.productDir, nodePath }, deps);
-    refreshEvidence();
-    return outcomesCoverPaths(dispatch.outcomes, nodeTestPaths) && recorded.status === TEST_RUN_STATE_STATUS.PASSED;
-  };
-}
-function coveredPathCollectionKey(coveredPaths) {
-  return JSON.stringify([...coveredPaths].sort(compareAsciiStrings));
-}
-async function loadResolverEvidence(deps) {
-  const discoveredTestPaths = await discoverTestFiles(deps.productDir);
-  const runs = await readTestingRuns(deps.productDir, deps);
-  return { discoveredTestPaths, terminalRuns: runs.ok ? runs.value.terminalRuns : [] };
-}
-function filterNodeTestPaths(discoveredTestPaths, nodePath) {
-  const prefix = `${nodePath}${PATH_SEPARATOR}`;
-  return discoveredTestPaths.filter((path7) => path7.startsWith(prefix));
-}
-async function usableRecordedOutcome(discoveredTestPaths, terminalRuns, nodeTestPaths, currentInputsFor) {
-  const latest = selectLatestTerminalTestRunForNode(terminalRuns, nodeTestPaths);
-  if (latest === void 0) {
-    return void 0;
-  }
-  const runCoveredPaths = latest.state.runnerOutcomes.flatMap((outcome) => outcome.testPaths);
-  const presentTestPaths = new Set(discoveredTestPaths);
-  if (!runCoveredPaths.every((path7) => presentTestPaths.has(path7))) {
-    return void 0;
-  }
-  const current = await currentInputsFor(runCoveredPaths);
-  const fresh = isStalenessMatch(extractStalenessInputs(latest.state), current);
-  return fresh && latest.state.status === TEST_RUN_STATE_STATUS.PASSED ? true : void 0;
-}
+// src/lib/node-status/ci-projection.ts
+import { parse as parseYaml3 } from "yaml";
 
 // src/lib/node-status/classify.ts
-var NODE_STATUS_STATUS_KEY = "status";
+var NODE_STATUS_SCHEMA_VERSION = 1;
 var NODE_STATUS_JSON_INDENT = 2;
+var NODE_STATUS_FIELD = {
+  SCHEMA_VERSION: "schemaVersion",
+  VERIFICATION: "verification",
+  OVERALL: "overall"
+};
+var NODE_STATUS_VERIFICATION_MECHANISM = {
+  TEST: "test",
+  EVAL: "eval",
+  AUDIT: "audit"
+};
+var NODE_STATUS_EVIDENCE_OUTCOME = {
+  PASSED: "passed",
+  FAILED: "failed",
+  NOT_RUN: "not-run"
+};
+var NODE_STATUS_MECHANISM_OVERALL = {
+  PASSED: NODE_STATUS_EVIDENCE_OUTCOME.PASSED,
+  FAILED: NODE_STATUS_EVIDENCE_OUTCOME.FAILED,
+  PARTIAL: "partial",
+  NOT_RUN: NODE_STATUS_EVIDENCE_OUTCOME.NOT_RUN
+};
 function classifyNodeStatus(facts) {
-  if (!facts.hasTests) return SPEC_TREE_NODE_STATE.DECLARED;
+  if (!facts.hasVerificationReferences) return SPEC_TREE_NODE_STATE.DECLARED;
   if (facts.isExcluded) return SPEC_TREE_NODE_STATE.SPECIFIED;
-  if (facts.testsPass) return SPEC_TREE_NODE_STATE.PASSING;
+  if (verificationPassed(facts.verification)) return SPEC_TREE_NODE_STATE.PASSING;
   return SPEC_TREE_NODE_STATE.FAILING;
 }
-function serializeNodeStatus(state) {
-  return `${JSON.stringify({ [NODE_STATUS_STATUS_KEY]: state }, null, NODE_STATUS_JSON_INDENT)}
+function createNodeStatusFile(verification) {
+  return {
+    [NODE_STATUS_FIELD.SCHEMA_VERSION]: NODE_STATUS_SCHEMA_VERSION,
+    [NODE_STATUS_FIELD.VERIFICATION]: verification
+  };
+}
+function hasNodeStatusVerificationReferences(verification) {
+  return Object.values(verification).some(
+    (mechanism) => Object.keys(mechanism).some((reference) => reference !== NODE_STATUS_FIELD.OVERALL)
+  );
+}
+function createNodeStatusMechanismRecord(outcomes) {
+  return {
+    [NODE_STATUS_FIELD.OVERALL]: rollupNodeStatusMechanism(outcomes),
+    ...outcomes
+  };
+}
+function rollupNodeStatusMechanism(outcomes) {
+  const values = Object.values(outcomes);
+  if (values.length === 0) return NODE_STATUS_MECHANISM_OVERALL.NOT_RUN;
+  if (values.includes(NODE_STATUS_EVIDENCE_OUTCOME.FAILED)) {
+    return NODE_STATUS_MECHANISM_OVERALL.FAILED;
+  }
+  if (values.every((outcome) => outcome === NODE_STATUS_EVIDENCE_OUTCOME.PASSED)) {
+    return NODE_STATUS_MECHANISM_OVERALL.PASSED;
+  }
+  if (values.every((outcome) => outcome === NODE_STATUS_EVIDENCE_OUTCOME.NOT_RUN)) {
+    return NODE_STATUS_MECHANISM_OVERALL.NOT_RUN;
+  }
+  return NODE_STATUS_MECHANISM_OVERALL.PARTIAL;
+}
+function serializeNodeStatus(status) {
+  return `${JSON.stringify(status, null, NODE_STATUS_JSON_INDENT)}
 `;
 }
+function verificationPassed(verification) {
+  if (verification === void 0) return false;
+  const mechanisms = Object.values(verification);
+  return mechanisms.length > 0 && mechanisms.every((mechanism) => mechanism[NODE_STATUS_FIELD.OVERALL] === NODE_STATUS_MECHANISM_OVERALL.PASSED);
+}
 
 // src/lib/node-status/provider.ts
 import { join as join20 } from "path";
 
+// src/lib/node-status/exclude.ts
+function isNodeStatusEntryExcluded(ignoreReader, node) {
+  const reference = node.ref?.path;
+  if (reference === void 0) return false;
+  return ignoreReader.isUnderIgnoreSource(reference);
+}
+
 // src/lib/node-status/read.ts
 import { readFileSync as readFileSync2 } from "fs";
 import { join as join19 } from "path";
 var NODE_STATUS_FILENAME = "spx.status.json";
-var NODE_STATUS_VALUES = new Set(Object.values(SPEC_TREE_NODE_STATE));
+var NODE_STATUS_MECHANISMS = new Set(Object.values(NODE_STATUS_VERIFICATION_MECHANISM));
+var NODE_STATUS_EVIDENCE_OUTCOMES = new Set(Object.values(NODE_STATUS_EVIDENCE_OUTCOME));
+var NODE_STATUS_OVERALL_VALUES = new Set(Object.values(NODE_STATUS_MECHANISM_OVERALL));
 function isNodeError2(error) {
   return error instanceof Error && "code" in error;
 }
-function isSpecTreeNodeState(value) {
-  return typeof value === "string" && NODE_STATUS_VALUES.has(value);
+function isObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isNodeStatusMechanism(value) {
+  return NODE_STATUS_MECHANISMS.has(value);
+}
+function isNodeStatusEvidenceOutcome(value) {
+  return typeof value === "string" && NODE_STATUS_EVIDENCE_OUTCOMES.has(value);
+}
+function isNodeStatusMechanismOverall(value) {
+  return typeof value === "string" && NODE_STATUS_OVERALL_VALUES.has(value);
 }
 function readNodeStatus(nodeDir) {
   const filePath = join19(nodeDir, NODE_STATUS_FILENAME);
@@ -9179,14 +9349,67 @@ function readNodeStatus(nodeDir) {
     }
     throw error;
   }
-  const parsed = JSON.parse(content);
-  const status = parsed[NODE_STATUS_STATUS_KEY];
-  if (!isSpecTreeNodeState(status)) {
+  return parseNodeStatusFile(JSON.parse(content), filePath);
+}
+function parseNodeStatusFile(candidate, source) {
+  if (!isObject(candidate)) {
+    throw new Error(`Invalid ${NODE_STATUS_FILENAME} at ${source}: expected a JSON object`);
+  }
+  if (candidate[NODE_STATUS_FIELD.SCHEMA_VERSION] !== NODE_STATUS_SCHEMA_VERSION) {
+    throw new Error(
+      `Invalid ${NODE_STATUS_FILENAME} at ${source}: schemaVersion must be ${NODE_STATUS_SCHEMA_VERSION}`
+    );
+  }
+  const verification = parseVerification(candidate[NODE_STATUS_FIELD.VERIFICATION], source);
+  return {
+    [NODE_STATUS_FIELD.SCHEMA_VERSION]: NODE_STATUS_SCHEMA_VERSION,
+    [NODE_STATUS_FIELD.VERIFICATION]: verification
+  };
+}
+function parseVerification(candidate, source) {
+  if (!isObject(candidate)) {
+    throw new Error(`Invalid ${NODE_STATUS_FILENAME} at ${source}: verification must be an object`);
+  }
+  const verification = {};
+  for (const [mechanism, rawRecord] of Object.entries(candidate)) {
+    if (!isNodeStatusMechanism(mechanism)) {
+      throw new Error(`Invalid ${NODE_STATUS_FILENAME} at ${source}: unknown verification mechanism "${mechanism}"`);
+    }
+    verification[mechanism] = parseMechanismRecord(rawRecord, source, mechanism);
+  }
+  return verification;
+}
+function parseMechanismRecord(candidate, source, mechanism) {
+  if (!isObject(candidate)) {
+    throw new Error(`Invalid ${NODE_STATUS_FILENAME} at ${source}: verification.${mechanism} must be an object`);
+  }
+  const overall = candidate[NODE_STATUS_FIELD.OVERALL];
+  if (!isNodeStatusMechanismOverall(overall)) {
+    throw new Error(
+      `Invalid ${NODE_STATUS_FILENAME} at ${source}: verification.${mechanism}.overall is invalid`
+    );
+  }
+  const parsed = {
+    [NODE_STATUS_FIELD.OVERALL]: overall
+  };
+  const outcomes = {};
+  for (const [reference, outcome] of Object.entries(candidate)) {
+    if (reference === NODE_STATUS_FIELD.OVERALL) continue;
+    if (!isNodeStatusEvidenceOutcome(outcome)) {
+      throw new Error(
+        `Invalid ${NODE_STATUS_FILENAME} at ${source}: verification.${mechanism}.${reference} is invalid`
+      );
+    }
+    outcomes[reference] = outcome;
+    parsed[reference] = outcome;
+  }
+  const expectedOverall = rollupNodeStatusMechanism(outcomes);
+  if (overall !== expectedOverall) {
     throw new Error(
-      `Invalid ${NODE_STATUS_FILENAME} at ${filePath}: status "${String(status)}" is not a lifecycle state`
+      `Invalid ${NODE_STATUS_FILENAME} at ${source}: verification.${mechanism}.overall does not match evidence outcomes`
     );
   }
-  return status;
+  return parsed;
 }
 
 // src/lib/node-status/provider.ts
@@ -9194,56 +9417,194 @@ function nodeDirectory(productDir, node) {
   return join20(productDir, SPEC_TREE_CONFIG.ROOT_DIRECTORY, node.id);
 }
 function createNodeStatusProvider(productDir) {
+  const ignoreReader = createIgnoreSourceReader(productDir, {
+    ignoreSourceFilename: IGNORE_SOURCE_FILENAME_DEFAULT,
+    specTreeRootSegment: SPEC_TREE_CONFIG.ROOT_DIRECTORY
+  });
   return {
     stateForNode(node) {
-      return readNodeStatus(nodeDirectory(productDir, node));
+      const status = readNodeStatus(nodeDirectory(productDir, node));
+      if (status === void 0) return void 0;
+      return classifyNodeStatus({
+        hasVerificationReferences: hasNodeStatusVerificationReferences(status.verification),
+        isExcluded: isNodeStatusEntryExcluded(ignoreReader, node),
+        verification: status.verification
+      });
+    }
+  };
+}
+
+// src/lib/node-status/update.ts
+import { mkdir as mkdir4, readdir as readdir7, rm, writeFile as writeFile2 } from "fs/promises";
+import { dirname as dirname6, join as join21 } from "path";
+var NODE_STATUS_TEXT_ENCODING = "utf8";
+async function updateNodeStatus(options) {
+  const { productDir, resolveOutcome } = options;
+  const snapshot = await readSpecTree({ source: createFilesystemSpecTreeSource({ productDir }) });
+  const ignoreReader = createIgnoreSourceReader(productDir, {
+    ignoreSourceFilename: IGNORE_SOURCE_FILENAME_DEFAULT,
+    specTreeRootSegment: SPEC_TREE_CONFIG.ROOT_DIRECTORY
+  });
+  const evidenceByNode = collectEvidenceByNode(snapshot);
+  const liveStatusPaths = /* @__PURE__ */ new Set();
+  for (const node of snapshot.allNodes) {
+    const evidence = evidenceByNode.get(node.id) ?? [];
+    const verification = await resolveVerification(node, {
+      evidence,
+      isExcluded: isNodeStatusEntryExcluded(ignoreReader, node),
+      resolveOutcome
+    });
+    const statusPath = nodeStatusPath(productDir, node.id);
+    liveStatusPaths.add(statusPath);
+    await writeNodeStatus(statusPath, verification);
+  }
+  await removeStaleNodeStatusFiles(productDir, liveStatusPaths);
+}
+async function resolveVerification(node, input) {
+  if (input.evidence.length === 0) return {};
+  if (input.isExcluded) return createTestVerification(input.evidence, NODE_STATUS_EVIDENCE_OUTCOME.NOT_RUN);
+  return createTestVerificationFromOutcomes(
+    input.evidence,
+    await input.resolveOutcome(node.id, evidencePaths(input.evidence))
+  );
+}
+function collectEvidenceByNode(snapshot) {
+  const evidenceByNode = /* @__PURE__ */ new Map();
+  for (const entry of snapshot.entries) {
+    if (entry.type === SPEC_TREE_ENTRY_TYPE.EVIDENCE) {
+      const entries = evidenceByNode.get(entry.parentId) ?? [];
+      entries.push(entry);
+      evidenceByNode.set(entry.parentId, entries);
+    }
+  }
+  return evidenceByNode;
+}
+function createTestVerification(evidence, outcome) {
+  const outcomes = Object.fromEntries(evidence.map((entry) => [evidencePath(entry), outcome]));
+  return createTestVerificationFromOutcomes(evidence, outcomes);
+}
+function createTestVerificationFromOutcomes(evidence, resolvedOutcomes) {
+  const outcomes = {};
+  for (const entry of evidence) {
+    const path7 = evidencePath(entry);
+    outcomes[path7] = resolvedOutcomes[path7] ?? NODE_STATUS_EVIDENCE_OUTCOME.NOT_RUN;
+  }
+  return { [NODE_STATUS_VERIFICATION_MECHANISM.TEST]: createNodeStatusMechanismRecord(outcomes) };
+}
+function evidencePaths(evidence) {
+  return evidence.map(evidencePath);
+}
+function evidencePath(entry) {
+  return entry.ref?.path ?? entry.id;
+}
+async function writeNodeStatus(filePath, verification) {
+  await mkdir4(dirname6(filePath), { recursive: true });
+  await writeFile2(filePath, serializeNodeStatus(createNodeStatusFile(verification)), NODE_STATUS_TEXT_ENCODING);
+}
+function nodeStatusPath(productDir, nodeId) {
+  return join21(productDir, SPEC_TREE_CONFIG.ROOT_DIRECTORY, nodeId, NODE_STATUS_FILENAME);
+}
+async function removeStaleNodeStatusFiles(productDir, liveStatusPaths) {
+  const statusPaths = await collectNodeStatusFiles(join21(productDir, SPEC_TREE_CONFIG.ROOT_DIRECTORY));
+  await Promise.all(statusPaths.filter((path7) => !liveStatusPaths.has(path7)).map((path7) => rm(path7, { force: true })));
+}
+async function collectNodeStatusFiles(directory) {
+  const entries = await readDirectoryEntries(directory);
+  const statusPaths = [];
+  for (const entry of entries) {
+    const entryPath = join21(directory, entry.name);
+    if (entry.isDirectory()) {
+      statusPaths.push(...await collectNodeStatusFiles(entryPath));
+    } else if (entry.isFile() && entry.name === NODE_STATUS_FILENAME) {
+      statusPaths.push(entryPath);
+    }
+  }
+  return statusPaths;
+}
+async function readDirectoryEntries(directory) {
+  try {
+    return await readdir7(directory, { withFileTypes: true });
+  } catch (error) {
+    if (isNodeError3(error) && error.code === "ENOENT") return [];
+    throw error;
+  }
+}
+function isNodeError3(error) {
+  return error instanceof Error && "code" in error;
+}
+
+// src/commands/spec/node-outcome-resolver.ts
+var PATH_SEPARATOR = "/";
+var SUCCESS_EXIT_CODE2 = 0;
+function createNodeOutcomeResolver(deps) {
+  let evidence;
+  const currentInputsByCoveredPaths = /* @__PURE__ */ new Map();
+  const sharedEvidence = () => evidence ??= loadResolverEvidence(deps);
+  const refreshEvidence = () => {
+    evidence = loadResolverEvidence(deps);
+  };
+  const currentInputsFor = (coveredPaths) => {
+    const cacheKey = coveredPathCollectionKey(coveredPaths);
+    const cached = currentInputsByCoveredPaths.get(cacheKey);
+    if (cached !== void 0) {
+      return cached;
     }
+    const current = currentStalenessInputs(deps.productDir, coveredPaths, deps);
+    currentInputsByCoveredPaths.set(cacheKey, current);
+    return current;
   };
+  return async (nodeId, evidencePaths2) => {
+    const { discoveredTestPaths, terminalRuns } = await sharedEvidence();
+    const nodePath = `${SPEC_TREE_CONFIG.ROOT_DIRECTORY}${PATH_SEPARATOR}${nodeId}`;
+    const nodeTestPaths = filterNodeTestPaths(discoveredTestPaths, nodePath, evidencePaths2);
+    const usable = await usableRecordedOutcome(discoveredTestPaths, terminalRuns, nodeTestPaths, currentInputsFor);
+    if (usable !== void 0) {
+      return usable;
+    }
+    const { dispatch } = await runNodeCommand({ productDir: deps.productDir, nodePath }, deps);
+    refreshEvidence();
+    return outcomesForPaths(dispatch.outcomes, nodeTestPaths);
+  };
+}
+function coveredPathCollectionKey(coveredPaths) {
+  return JSON.stringify([...coveredPaths].sort(compareAsciiStrings));
 }
-
-// src/lib/node-status/update.ts
-import { mkdir as mkdir4, writeFile as writeFile2 } from "fs/promises";
-import { dirname as dirname6, join as join21 } from "path";
-var NODE_STATUS_TEXT_ENCODING = "utf8";
-async function updateNodeStatus(options) {
-  const { productDir, resolveOutcome } = options;
-  const snapshot = await readSpecTree({ source: createFilesystemSpecTreeSource({ productDir }) });
-  const ignoreReader = createIgnoreSourceReader(productDir, {
-    ignoreSourceFilename: IGNORE_SOURCE_FILENAME_DEFAULT,
-    specTreeRootSegment: SPEC_TREE_CONFIG.ROOT_DIRECTORY
-  });
-  const nodesWithTests = collectNodesWithTests(snapshot);
-  for (const node of snapshot.allNodes) {
-    const facts = await classifyFacts(node, {
-      hasTests: nodesWithTests.has(node.id),
-      isExcluded: isNodeExcluded(ignoreReader, node),
-      resolveOutcome
-    });
-    await writeNodeStatus(productDir, node.id, classifyNodeStatus(facts));
-  }
+async function loadResolverEvidence(deps) {
+  const discoveredTestPaths = await discoverTestFiles(deps.productDir);
+  const runs = await readTestingRuns(deps.productDir, deps);
+  return { discoveredTestPaths, terminalRuns: runs.ok ? runs.value.terminalRuns : [] };
 }
-async function classifyFacts(node, input) {
-  const testsPass = input.hasTests && !input.isExcluded ? await input.resolveOutcome(node.id) : false;
-  return { hasTests: input.hasTests, isExcluded: input.isExcluded, testsPass };
+function filterNodeTestPaths(discoveredTestPaths, nodePath, evidencePaths2) {
+  const prefix = `${nodePath}${PATH_SEPARATOR}`;
+  const discovered = new Set(discoveredTestPaths.filter((path7) => path7.startsWith(prefix)));
+  return evidencePaths2.filter((path7) => discovered.has(path7));
 }
-function collectNodesWithTests(snapshot) {
-  const parents = /* @__PURE__ */ new Set();
-  for (const entry of snapshot.entries) {
-    if (entry.type === SPEC_TREE_ENTRY_TYPE.EVIDENCE) {
-      parents.add(entry.parentId);
-    }
+async function usableRecordedOutcome(discoveredTestPaths, terminalRuns, nodeTestPaths, currentInputsFor) {
+  const latest = selectLatestTerminalTestRunForNode(terminalRuns, nodeTestPaths);
+  if (latest === void 0) {
+    return void 0;
+  }
+  const runCoveredPaths = latest.state.runnerOutcomes.flatMap((outcome) => outcome.testPaths);
+  const presentTestPaths = new Set(discoveredTestPaths);
+  if (!runCoveredPaths.every((path7) => presentTestPaths.has(path7))) {
+    return void 0;
   }
-  return parents;
+  const current = await currentInputsFor(runCoveredPaths);
+  const fresh = isStalenessMatch(extractStalenessInputs(latest.state), current);
+  return fresh && latest.state.status === TEST_RUN_STATE_STATUS.PASSED ? outcomesForPaths(latest.state.runnerOutcomes, nodeTestPaths) : void 0;
 }
-function isNodeExcluded(ignoreReader, node) {
-  const reference = node.ref?.path;
-  if (reference === void 0) return false;
-  return ignoreReader.isUnderIgnoreSource(reference);
+function outcomesForPaths(outcomes, nodeTestPaths) {
+  return Object.fromEntries(
+    nodeTestPaths.map((path7) => [path7, outcomeForPath(outcomes, path7)])
+  );
 }
-async function writeNodeStatus(productDir, nodeId, state) {
-  const filePath = join21(productDir, SPEC_TREE_CONFIG.ROOT_DIRECTORY, nodeId, NODE_STATUS_FILENAME);
-  await mkdir4(dirname6(filePath), { recursive: true });
-  await writeFile2(filePath, serializeNodeStatus(state), NODE_STATUS_TEXT_ENCODING);
+function outcomeForPath(outcomes, path7) {
+  const covering = outcomes.filter((outcome) => outcome.testPaths.includes(path7));
+  if (covering.length === 0) return NODE_STATUS_EVIDENCE_OUTCOME.NOT_RUN;
+  if (covering.every((outcome) => outcome.exitCode === SUCCESS_EXIT_CODE2)) {
+    return NODE_STATUS_EVIDENCE_OUTCOME.PASSED;
+  }
+  return NODE_STATUS_EVIDENCE_OUTCOME.FAILED;
 }
 
 // src/commands/spec/status.ts
@@ -9954,8 +10315,9 @@ function createTestingDomain(deps = defaultTestingCliDependencies) {
 }
 var testingDomain = createTestingDomain();
 
-// src/commands/validation/markdown.ts
-import { relative as relative3 } from "path";
+// src/commands/validation/formatting.ts
+import { existsSync } from "fs";
+import { isAbsolute as isAbsolute3, join as join24, relative as relative3 } from "path";
 
 // src/validation/config/path-filter.ts
 import { isAbsolute as isAbsolute2, relative as relative2 } from "path";
@@ -10052,9 +10414,180 @@ function applyValidationPathFilterToScope(scopeConfig, filter) {
   };
 }
 
+// src/validation/steps/subprocess-output.ts
+var VALIDATION_SUBPROCESS_EVENTS = {
+  CLOSE: "close",
+  DATA: "data",
+  DRAIN: "drain",
+  ERROR: "error"
+};
+var defaultValidationSubprocessOutputStreams = {
+  stdout: process.stdout,
+  stderr: process.stderr
+};
+function forwardValidationSubprocessOutput(child, streams = defaultValidationSubprocessOutputStreams) {
+  child.stdout?.on(VALIDATION_SUBPROCESS_EVENTS.DATA, (chunk) => {
+    forwardChunkWithBackpressure(child.stdout, streams.stdout, chunk);
+  });
+  child.stderr?.on(VALIDATION_SUBPROCESS_EVENTS.DATA, (chunk) => {
+    forwardChunkWithBackpressure(child.stderr, streams.stderr, chunk);
+  });
+}
+function forwardChunkWithBackpressure(source, stream, chunk) {
+  const ready = stream.write(chunk);
+  if (ready || stream.once === void 0 || source === null || source === void 0) {
+    return;
+  }
+  source.pause();
+  stream.once(VALIDATION_SUBPROCESS_EVENTS.DRAIN, () => {
+    source.resume();
+  });
+}
+
+// src/validation/steps/formatting.ts
+var DPRINT_COMMAND = "dprint";
+var DPRINT_CHECK_SUBCOMMAND = "check";
+var DPRINT_CONFIG_FILENAME = "dprint.jsonc";
+var defaultFormattingProcessRunner = lifecycleProcessRunner;
+function buildDprintCheckArgs(options) {
+  return [DPRINT_CHECK_SUBCOMMAND, ...options.files ?? []];
+}
+async function validateFormatting(context, runner = defaultFormattingProcessRunner) {
+  const args = buildDprintCheckArgs({ files: context.files });
+  return new Promise((resolve8) => {
+    const child = spawnManagedSubprocess(runner, DPRINT_COMMAND, args, { cwd: context.projectRoot });
+    const chunks = [];
+    const capture = (chunk) => {
+      chunks.push(typeof chunk === "string" ? chunk : Buffer.from(chunk).toString());
+    };
+    child.stdout?.on(VALIDATION_SUBPROCESS_EVENTS.DATA, capture);
+    child.stderr?.on(VALIDATION_SUBPROCESS_EVENTS.DATA, capture);
+    child.on(VALIDATION_SUBPROCESS_EVENTS.CLOSE, (code) => {
+      resolve8({ success: code === 0, output: chunks.join("") });
+    });
+    child.on(VALIDATION_SUBPROCESS_EVENTS.ERROR, (error) => {
+      resolve8({ success: false, output: chunks.join(""), error: error.message });
+    });
+  });
+}
+
+// src/commands/validation/messages.ts
+var VALIDATION_STAGE_DISPLAY_NAMES = {
+  CIRCULAR: "dependency-cruiser",
+  KNIP: "Knip",
+  ESLINT: "ESLint",
+  TYPESCRIPT: "TypeScript",
+  MARKDOWN: "Markdown",
+  LITERAL: "Literal",
+  FORMATTING: "Formatting"
+};
+var VALIDATION_SKIP_LABELS = {
+  VERB: "Skipping",
+  CIRCULAR_REASON: "skip-circular",
+  LITERAL_REASON: "skip-literal",
+  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_DEFAULT_DIRECTORIES_REASON: "no spx/ or docs/ directories found"
+};
+var VALIDATION_COMMAND_OUTPUT = {
+  CIRCULAR_FOUND: `${VALIDATION_STAGE_DISPLAY_NAMES.CIRCULAR}: circular dependencies found`,
+  CIRCULAR_NONE_FOUND: `${VALIDATION_STAGE_DISPLAY_NAMES.CIRCULAR}: \u2713 No circular dependencies found`,
+  KNIP_CONFIG_ERROR: `${VALIDATION_STAGE_DISPLAY_NAMES.KNIP}: \u2717 config error`,
+  KNIP_DISABLED: `${VALIDATION_STAGE_DISPLAY_NAMES.KNIP}: skipped (${VALIDATION_SKIP_LABELS.DISABLED_BY_PREFIX} validation.knip.enabled)`,
+  KNIP_SUCCESS: `${VALIDATION_STAGE_DISPLAY_NAMES.KNIP}: \u2713 No unused code found`,
+  KNIP_FAILURE: "Unused code found",
+  ESLINT_SUCCESS: `${VALIDATION_STAGE_DISPLAY_NAMES.ESLINT}: \u2713 No errors found`,
+  ESLINT_FAILURE: `${VALIDATION_STAGE_DISPLAY_NAMES.ESLINT} validation failed`,
+  ESLINT_MISSING_CONFIG: "ESLint config not found: project has tsconfig.json but no eslint.config.{ts,js,mjs,cjs}",
+  TYPESCRIPT_SUCCESS: `${VALIDATION_STAGE_DISPLAY_NAMES.TYPESCRIPT}: \u2713 No type errors`,
+  TYPESCRIPT_FAILURE: `${VALIDATION_STAGE_DISPLAY_NAMES.TYPESCRIPT} validation failed`,
+  MARKDOWN_NO_ISSUES: `${VALIDATION_STAGE_DISPLAY_NAMES.MARKDOWN}: No issues found`,
+  MARKDOWN_ERROR_SUMMARY_SUFFIX: "error(s) found",
+  FORMATTING_NO_ISSUES: `${VALIDATION_STAGE_DISPLAY_NAMES.FORMATTING}: \u2713 No formatting issues found`,
+  FORMATTING_FAILURE_SUMMARY: `${VALIDATION_STAGE_DISPLAY_NAMES.FORMATTING}: unformatted files found`
+};
+var CIRCULAR_SKIP_OUTPUT = `${VALIDATION_STAGE_DISPLAY_NAMES.CIRCULAR}: skipped (--${VALIDATION_SKIP_LABELS.CIRCULAR_REASON})`;
+var CIRCULAR_SKIP_JSON_OUTPUT = JSON.stringify({
+  skipped: true,
+  reason: VALIDATION_SKIP_LABELS.CIRCULAR_REASON
+});
+var LITERAL_SKIP_OUTPUT = `${VALIDATION_STAGE_DISPLAY_NAMES.LITERAL}: skipped (--${VALIDATION_SKIP_LABELS.LITERAL_REASON})`;
+var LITERAL_SKIP_JSON_OUTPUT = JSON.stringify({
+  skipped: true,
+  reason: VALIDATION_SKIP_LABELS.LITERAL_REASON
+});
+function formatTypeScriptAbsentSkipMessage(stageName) {
+  return `\u23ED ${VALIDATION_SKIP_LABELS.VERB} ${stageName} (${VALIDATION_SKIP_LABELS.TYPESCRIPT_ABSENT_REASON})`;
+}
+function formatValidationPathsNoTargetsSkipMessage(stageName) {
+  return `\u23ED ${VALIDATION_SKIP_LABELS.VERB} ${stageName} (${VALIDATION_SKIP_LABELS.VALIDATION_PATHS_NO_TARGETS_REASON})`;
+}
+
+// src/commands/validation/formatting.ts
+var FORMATTING_COMMAND_OUTPUT = {
+  NO_ISSUES: VALIDATION_COMMAND_OUTPUT.FORMATTING_NO_ISSUES,
+  FAILURE_SUMMARY: VALIDATION_COMMAND_OUTPUT.FORMATTING_FAILURE_SUMMARY,
+  EMPTY_SCOPE_REASON: "no files in scope",
+  NO_CONFIG_SKIP_REASON: `no ${DPRINT_CONFIG_FILENAME} at product root`
+};
+var FORMATTING_CONFIG_ERROR_MESSAGE = `${VALIDATION_STAGE_DISPLAY_NAMES.FORMATTING}: \u2717 config error`;
+async function formattingCommand(options) {
+  const { cwd, files, quiet } = options;
+  const startTime = Date.now();
+  const loaded = await resolveConfig(cwd, [validationConfigDescriptor]);
+  if (!loaded.ok) {
+    return {
+      exitCode: 1,
+      output: `${FORMATTING_CONFIG_ERROR_MESSAGE} \u2014 ${loaded.error}`,
+      durationMs: Date.now() - startTime
+    };
+  }
+  const validationConfig = loaded.value[validationConfigDescriptor.section];
+  if (!existsSync(join24(cwd, DPRINT_CONFIG_FILENAME))) {
+    const output2 = quiet ? "" : `${VALIDATION_STAGE_DISPLAY_NAMES.FORMATTING}: skipped (${FORMATTING_COMMAND_OUTPUT.NO_CONFIG_SKIP_REASON})`;
+    return { exitCode: 0, output: output2, durationMs: Date.now() - startTime };
+  }
+  const pathFilter = validationPathFilterForTool(
+    validationConfig.paths,
+    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;
+  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 durationMs = Date.now() - startTime;
+  if (result.success) {
+    return { exitCode: 0, output: quiet ? "" : FORMATTING_COMMAND_OUTPUT.NO_ISSUES, durationMs };
+  }
+  const detail = result.error ?? result.output;
+  const output = [FORMATTING_COMMAND_OUTPUT.FAILURE_SUMMARY, detail].filter((line) => line.length > 0).join("\n");
+  return { exitCode: 1, output, durationMs };
+}
+
+// src/validation/languages/formatting.ts
+var FORMATTING_LANGUAGE_NAME = "formatting";
+var formattingValidationLanguage = {
+  name: FORMATTING_LANGUAGE_NAME,
+  stages: [
+    {
+      name: VALIDATION_STAGE_DISPLAY_NAMES.FORMATTING,
+      failsPipeline: true,
+      run: (context) => formattingCommand({ cwd: context.cwd, files: context.files, quiet: context.quiet })
+    }
+  ]
+};
+
+// src/commands/validation/markdown.ts
+import { relative as relative4 } from "path";
+
 // src/validation/steps/markdown.ts
-import { existsSync, statSync } from "fs";
-import { basename as basename4, dirname as dirname8, join as join24, relative as pathRelative } from "path";
+import { existsSync as existsSync2, statSync } from "fs";
+import { basename as basename4, dirname as dirname8, join as join25, relative as pathRelative } from "path";
 import { main as markdownlintMain } from "markdownlint-cli2";
 import relativeLinksRule from "markdownlint-rule-relative-links";
 var MARKDOWN_DEFAULT_DIRECTORY_NAMES = ["spx", "docs"];
@@ -10093,7 +10626,7 @@ function buildMarkdownlintConfig(directoryName) {
   };
 }
 function getDefaultDirectories(projectRoot) {
-  return MARKDOWN_DEFAULT_DIRECTORY_NAMES.map((name) => join24(projectRoot, name)).filter((dir) => existsSync(dir));
+  return MARKDOWN_DEFAULT_DIRECTORY_NAMES.map((name) => join25(projectRoot, name)).filter((dir) => existsSync2(dir));
 }
 function resolveMarkdownValidationTarget(path7, deps = defaultMarkdownValidationTargetDeps) {
   if (isExistingDirectory(path7, deps)) {
@@ -10176,7 +10709,7 @@ async function validateTarget(target, config, projectRoot, ignoreGlobs = []) {
       if (parsed) {
         errors.push({
           ...parsed,
-          file: join24(directory, parsed.file)
+          file: join25(directory, parsed.file)
         });
       }
     }
@@ -10215,57 +10748,6 @@ function markdownlintConfigDirectoryName(directory, projectRoot) {
   return basename4(directory);
 }
 
-// src/commands/validation/messages.ts
-var VALIDATION_STAGE_DISPLAY_NAMES = {
-  CIRCULAR: "dependency-cruiser",
-  KNIP: "Knip",
-  ESLINT: "ESLint",
-  TYPESCRIPT: "TypeScript",
-  MARKDOWN: "Markdown",
-  LITERAL: "Literal"
-};
-var VALIDATION_SKIP_LABELS = {
-  VERB: "Skipping",
-  CIRCULAR_REASON: "skip-circular",
-  LITERAL_REASON: "skip-literal",
-  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_DEFAULT_DIRECTORIES_REASON: "no spx/ or docs/ directories found"
-};
-var VALIDATION_COMMAND_OUTPUT = {
-  CIRCULAR_FOUND: `${VALIDATION_STAGE_DISPLAY_NAMES.CIRCULAR}: circular dependencies found`,
-  CIRCULAR_NONE_FOUND: `${VALIDATION_STAGE_DISPLAY_NAMES.CIRCULAR}: \u2713 No circular dependencies found`,
-  KNIP_CONFIG_ERROR: `${VALIDATION_STAGE_DISPLAY_NAMES.KNIP}: \u2717 config error`,
-  KNIP_DISABLED: `${VALIDATION_STAGE_DISPLAY_NAMES.KNIP}: skipped (${VALIDATION_SKIP_LABELS.DISABLED_BY_PREFIX} validation.knip.enabled)`,
-  KNIP_SUCCESS: `${VALIDATION_STAGE_DISPLAY_NAMES.KNIP}: \u2713 No unused code found`,
-  KNIP_FAILURE: "Unused code found",
-  ESLINT_SUCCESS: `${VALIDATION_STAGE_DISPLAY_NAMES.ESLINT}: \u2713 No errors found`,
-  ESLINT_FAILURE: `${VALIDATION_STAGE_DISPLAY_NAMES.ESLINT} validation failed`,
-  ESLINT_MISSING_CONFIG: "ESLint config not found: project has tsconfig.json but no eslint.config.{ts,js,mjs,cjs}",
-  TYPESCRIPT_SUCCESS: `${VALIDATION_STAGE_DISPLAY_NAMES.TYPESCRIPT}: \u2713 No type errors`,
-  TYPESCRIPT_FAILURE: `${VALIDATION_STAGE_DISPLAY_NAMES.TYPESCRIPT} validation failed`,
-  MARKDOWN_NO_ISSUES: `${VALIDATION_STAGE_DISPLAY_NAMES.MARKDOWN}: No issues found`,
-  MARKDOWN_ERROR_SUMMARY_SUFFIX: "error(s) found"
-};
-var CIRCULAR_SKIP_OUTPUT = `${VALIDATION_STAGE_DISPLAY_NAMES.CIRCULAR}: skipped (--${VALIDATION_SKIP_LABELS.CIRCULAR_REASON})`;
-var CIRCULAR_SKIP_JSON_OUTPUT = JSON.stringify({
-  skipped: true,
-  reason: VALIDATION_SKIP_LABELS.CIRCULAR_REASON
-});
-var LITERAL_SKIP_OUTPUT = `${VALIDATION_STAGE_DISPLAY_NAMES.LITERAL}: skipped (--${VALIDATION_SKIP_LABELS.LITERAL_REASON})`;
-var LITERAL_SKIP_JSON_OUTPUT = JSON.stringify({
-  skipped: true,
-  reason: VALIDATION_SKIP_LABELS.LITERAL_REASON
-});
-function formatTypeScriptAbsentSkipMessage(stageName) {
-  return `\u23ED ${VALIDATION_SKIP_LABELS.VERB} ${stageName} (${VALIDATION_SKIP_LABELS.TYPESCRIPT_ABSENT_REASON})`;
-}
-function formatValidationPathsNoTargetsSkipMessage(stageName) {
-  return `\u23ED ${VALIDATION_SKIP_LABELS.VERB} ${stageName} (${VALIDATION_SKIP_LABELS.VALIDATION_PATHS_NO_TARGETS_REASON})`;
-}
-
 // src/commands/validation/markdown.ts
 var MARKDOWN_COMMAND_OUTPUT = {
   ERROR_SUMMARY_SUFFIX: VALIDATION_COMMAND_OUTPUT.MARKDOWN_ERROR_SUMMARY_SUFFIX,
@@ -10295,7 +10777,7 @@ async function markdownCommand(options) {
     path: path7
   }));
   const targets = unfilteredTargets.filter(
-    (target) => pathPassesValidationFilter(relative3(cwd, target.path), pathFilter)
+    (target) => pathPassesValidationFilter(relative4(cwd, target.path), pathFilter)
   );
   const skippedTargets = targetResolutions === void 0 ? [] : targetResolutions.map((resolution) => resolution.skipped).filter((skipped) => skipped !== void 0);
   const skippedOutput = quiet ? [] : skippedTargets.map(formatSkippedFileScope);
@@ -11204,8 +11686,8 @@ var ParseErrorCode;
 })(ParseErrorCode || (ParseErrorCode = {}));
 
 // src/validation/config/scope.ts
-import { existsSync as existsSync2, readdirSync, readFileSync as readFileSync3 } from "fs";
-import { isAbsolute as isAbsolute3, join as join25, relative as relative4, resolve as resolve6 } from "path";
+import { existsSync as existsSync3, readdirSync, readFileSync as readFileSync3 } from "fs";
+import { isAbsolute as isAbsolute4, join as join26, relative as relative5, resolve as resolve6 } from "path";
 var TSCONFIG_FILES = {
   full: "tsconfig.json",
   production: "tsconfig.production.json"
@@ -11234,7 +11716,7 @@ var TYPESCRIPT_FALLBACK_INCLUDE_PATTERNS = [
 var TEMPORARY_TSCONFIG_PARENT_SEGMENTS = ["node_modules", ".cache", "spx"];
 var defaultScopeDeps = {
   readFileSync: readFileSync3,
-  existsSync: existsSync2,
+  existsSync: existsSync3,
   readdirSync
 };
 var EXPLICIT_TYPESCRIPT_SCOPE_TARGET_KIND = {
@@ -11242,7 +11724,7 @@ var EXPLICIT_TYPESCRIPT_SCOPE_TARGET_KIND = {
   FILE: "file"
 };
 function resolveProjectPath(projectRoot, path7) {
-  return isAbsolute3(path7) ? path7 : join25(projectRoot, path7);
+  return isAbsolute4(path7) ? path7 : join26(projectRoot, path7);
 }
 function parseTypeScriptConfig(configPath, deps = defaultScopeDeps) {
   try {
@@ -11281,12 +11763,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(join25(dirPath, item.name), options)
+      (item) => item.isFile() && pathHasTypeScriptSourceExtension(item.name) && pathPassesTypeScriptFileDiscoveryExcludes(join26(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(join25(dirPath, subdir.name), maxDepth - 1, deps, options)) {
+      if (hasTypeScriptFilesRecursive(join26(dirPath, subdir.name), maxDepth - 1, deps, options)) {
         return true;
       }
     }
@@ -11323,7 +11805,7 @@ function directoryContributesTypeScriptScope(dir, config, projectRoot, deps) {
     return false;
   }
   try {
-    return hasTypeScriptFilesRecursive(join25(projectRoot, dir), 2, deps, {
+    return hasTypeScriptFilesRecursive(join26(projectRoot, dir), 2, deps, {
       excludePatterns: config.exclude,
       projectRoot
     });
@@ -11552,13 +12034,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(join25(projectRoot, topLevelDir));
+    return topLevelDir === null || deps.existsSync(join26(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(join25(projectRoot, dir)));
+  const existingDirectories = configDirectories.filter((dir) => deps.existsSync(join26(projectRoot, dir)));
   return existingDirectories;
 }
 function getTypeScriptScope(scope2, projectRoot, deps = defaultScopeDeps) {
@@ -11579,14 +12061,14 @@ function pathPassesTypeScriptScope(path7, scopeConfig) {
   return included && !excluded;
 }
 function pathStaysInsideTypeScriptScopeRoot(projectRoot, path7) {
-  const resolvedPath = isAbsolute3(path7) ? resolve6(path7) : resolve6(projectRoot, path7);
-  const relativePath = relative4(projectRoot, resolvedPath);
+  const resolvedPath = isAbsolute4(path7) ? resolve6(path7) : resolve6(projectRoot, path7);
+  const relativePath = relative5(projectRoot, resolvedPath);
   const segments = normalizeTypeScriptScopePath(relativePath).split(PATH_SEGMENT_SEPARATOR3);
-  return relativePath.length === 0 || !segments.includes("..") && !isAbsolute3(relativePath);
+  return relativePath.length === 0 || !segments.includes("..") && !isAbsolute4(relativePath);
 }
 function toProjectRelativeTypeScriptScopePath(projectRoot, path7) {
-  const resolvedPath = isAbsolute3(path7) ? resolve6(path7) : resolve6(projectRoot, path7);
-  const relativePath = relative4(projectRoot, resolvedPath);
+  const resolvedPath = isAbsolute4(path7) ? resolve6(path7) : resolve6(projectRoot, path7);
+  const relativePath = relative5(projectRoot, resolvedPath);
   return relativePath.length === 0 ? TYPESCRIPT_SCOPE_PROJECT_ROOT : normalizeTypeScriptScopePath(relativePath);
 }
 function toExplicitTypeScriptScopeTarget(projectRoot, originalPath, deps = defaultScopeDeps) {
@@ -11625,10 +12107,10 @@ function explicitTypeScriptScopeTargetPassesScope(target, scopeConfig) {
   if (typeScriptSourcePatterns.length > 0) {
     return typeScriptSourcePatterns.some((pattern) => typeScriptScopePatternIntersectsDirectory(pattern, target.path));
   }
-  return pathPassesTypeScriptScope(join25(target.path, TYPESCRIPT_SCOPE_DIRECTORY_PROBE_FILENAME), scopeConfig);
+  return pathPassesTypeScriptScope(join26(target.path, TYPESCRIPT_SCOPE_DIRECTORY_PROBE_FILENAME), scopeConfig);
 }
 function directoryPassesTypeScriptExcludes(directory, scopeConfig) {
-  const probePath = join25(directory, TYPESCRIPT_SCOPE_DIRECTORY_PROBE_FILENAME);
+  const probePath = join26(directory, TYPESCRIPT_SCOPE_DIRECTORY_PROBE_FILENAME);
   return !scopeConfig.excludePatterns.some(
     (pattern) => typeScriptScopePatternCoversDirectorySourceSet(pattern, directory) || pathMatchesTypeScriptPattern(probePath, pattern)
   );
@@ -11819,10 +12301,10 @@ function resolvedModulePath(resolvedPath) {
     return resolvedPath;
   }
 }
-function nearestPackageRoot(filePath, existsSync7) {
+function nearestPackageRoot(filePath, existsSync8) {
   let currentDirectory = path6.dirname(filePath);
   while (true) {
-    if (existsSync7(path6.join(currentDirectory, PACKAGE_MANIFEST_FILENAME))) {
+    if (existsSync8(path6.join(currentDirectory, PACKAGE_MANIFEST_FILENAME))) {
       return currentDirectory;
     }
     const parentDirectory = path6.dirname(currentDirectory);
@@ -11832,9 +12314,9 @@ function nearestPackageRoot(filePath, existsSync7) {
     currentDirectory = parentDirectory;
   }
 }
-function bundledToolPath(resolvedPath, existsSync7) {
+function bundledToolPath(resolvedPath, existsSync8) {
   const bundledFilePath = resolvedModulePath(resolvedPath);
-  return nearestPackageRoot(bundledFilePath, existsSync7) ?? path6.dirname(bundledFilePath);
+  return nearestPackageRoot(bundledFilePath, existsSync8) ?? path6.dirname(bundledFilePath);
 }
 async function discoverTool(tool, options = {}) {
   const { projectRoot = process.cwd(), deps = defaultToolDiscoveryDeps } = options;
@@ -11891,7 +12373,7 @@ import {
   cruise as dependencyCruiser
 } from "dependency-cruiser";
 import extractTypeScriptConfig from "dependency-cruiser/config-utl/extract-ts-config";
-import { join as join26 } from "path";
+import { join as join27 } 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)$`;
@@ -12131,7 +12613,7 @@ async function validateCircularDependencies(scope2, typescriptScope, projectRoot
     if (analyzeSourcePatterns.length === 0) {
       return { success: true };
     }
-    const tsConfigFile = join26(projectRoot, TSCONFIG_FILES[scope2]);
+    const tsConfigFile = join27(projectRoot, TSCONFIG_FILES[scope2]);
     const result = await deps.dependencyCruiser(
       analyzeSourcePatterns,
       buildDependencyCruiserOptions(typescriptScope, projectRoot, tsConfigFile),
@@ -12251,9 +12733,9 @@ async function circularCommand(options, deps = defaultCircularCommandDeps) {
 }
 
 // src/validation/steps/knip.ts
-import { existsSync as existsSync3 } from "fs";
-import { mkdir as mkdir5, mkdtemp as mkdtemp2, rm, writeFile as writeFile3 } from "fs/promises";
-import { isAbsolute as isAbsolute4, join as join27 } from "path";
+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";
 var defaultKnipProcessRunner = lifecycleProcessRunner;
 var KNIP_COMMAND_TOKENS = {
   COMMAND: "knip",
@@ -12262,10 +12744,10 @@ var KNIP_COMMAND_TOKENS = {
   USE_TSCONFIG_FILES_FLAG: "--use-tsconfig-files"
 };
 var defaultKnipDeps = {
-  existsSync: existsSync3,
+  existsSync: existsSync4,
   mkdir: mkdir5,
   mkdtemp: mkdtemp2,
-  rm,
+  rm: rm2,
   writeFile: writeFile3
 };
 async function validateKnip2(context, runner = defaultKnipProcessRunner, deps = defaultKnipDeps) {
@@ -12286,7 +12768,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 = join27(projectRoot, "node_modules", ".bin", "knip");
+  const localBin = join28(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,
@@ -12341,11 +12823,11 @@ async function runKnipSubprocess(projectRoot, typescriptScope, runner, deps) {
   });
 }
 async function createScopedKnipTsconfig(projectRoot, typescriptScope, deps) {
-  const tempParentDir = join27(projectRoot, ...TEMPORARY_TSCONFIG_PARENT_SEGMENTS);
+  const tempParentDir = join28(projectRoot, ...TEMPORARY_TSCONFIG_PARENT_SEGMENTS);
   await deps.mkdir(tempParentDir, { recursive: true });
-  const tempDir = await deps.mkdtemp(join27(tempParentDir, "validate-knip-"));
-  const configPath = join27(tempDir, TSCONFIG_FILES.full);
-  const toProjectPathPattern = (pattern) => isAbsolute4(pattern) ? pattern : join27(projectRoot, pattern);
+  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 project = [
     ...typescriptScope.directories.flatMap(
       (directory) => TYPESCRIPT_FALLBACK_INCLUDE_PATTERNS.map((pattern) => `${directory}/${pattern}`)
@@ -12353,7 +12835,7 @@ async function createScopedKnipTsconfig(projectRoot, typescriptScope, deps) {
     ...typescriptScope.filePatterns
   ];
   const config = {
-    extends: join27(projectRoot, TSCONFIG_FILES.full),
+    extends: join28(projectRoot, TSCONFIG_FILES.full),
     include: project.map(toProjectPathPattern),
     exclude: typescriptScope.excludePatterns.map(toProjectPathPattern)
   };
@@ -12419,13 +12901,13 @@ async function knipCommand(options, deps = defaultKnipCommandDeps) {
 }
 
 // src/validation/steps/eslint.ts
-import { existsSync as existsSync5 } from "fs";
-import { join as join29 } from "path";
+import { existsSync as existsSync6 } from "fs";
+import { join as join30 } from "path";
 
 // src/validation/lint-policy.ts
 import { execFileSync } from "child_process";
-import { existsSync as existsSync4, readdirSync as readdirSync2, readFileSync as readFileSync4, statSync as statSync2 } from "fs";
-import { join as join28 } from "path";
+import { existsSync as existsSync5, readdirSync as readdirSync2, readFileSync as readFileSync4, statSync as statSync2 } from "fs";
+import { join as join29 } from "path";
 
 // src/validation/lint-policy-constants.ts
 var LINT_POLICY_MANIFESTS = {
@@ -12471,19 +12953,19 @@ var BASE_BRANCH_REFS = [LINT_POLICY_BASE_REFS.REMOTE_MAIN, LINT_POLICY_BASE_REFS
 function isSpecTreeNodePath(entry) {
   return NODE_SUFFIXES.some((suffix) => entry.endsWith(suffix));
 }
-function readManifest(productDir, file, key) {
+function readManifest2(productDir, file, key) {
   return parseLintPolicyManifest(
-    readFileSync4(join28(productDir, file), "utf-8"),
+    readFileSync4(join29(productDir, file), "utf-8"),
     file,
     key
   );
 }
 function manifestExists(productDir, file) {
-  return existsSync4(join28(productDir, file));
+  return existsSync5(join29(productDir, file));
 }
 function findDeprecatedSpecNodePath(productDir) {
   function visit2(relativeDirectory) {
-    const absoluteDirectory = join28(productDir, relativeDirectory);
+    const absoluteDirectory = join29(productDir, relativeDirectory);
     for (const entry of readdirSync2(absoluteDirectory, { withFileTypes: true })) {
       if (!entry.isDirectory()) {
         continue;
@@ -12499,8 +12981,8 @@ function findDeprecatedSpecNodePath(productDir) {
     }
     return void 0;
   }
-  const specTreeRootPath = join28(productDir, SPEC_TREE_ROOT);
-  if (!existsSync4(specTreeRootPath)) {
+  const specTreeRootPath = join29(productDir, SPEC_TREE_ROOT);
+  if (!existsSync5(specTreeRootPath)) {
     return void 0;
   }
   return visit2(SPEC_TREE_ROOT);
@@ -12525,8 +13007,8 @@ function assertManifestEntries(productDir, file, entries, suffixPredicate, suffi
     if (!suffixPredicate(entry)) {
       throw new Error(`${file} entry must ${suffixDescription}: ${entry}`);
     }
-    const absoluteEntry = join28(productDir, entry);
-    if (!existsSync4(absoluteEntry) || !statSync2(absoluteEntry).isDirectory()) {
+    const absoluteEntry = join29(productDir, entry);
+    if (!existsSync5(absoluteEntry) || !statSync2(absoluteEntry).isDirectory()) {
       throw new Error(`${file} entry does not exist as a directory: ${entry}`);
     }
   }
@@ -12658,11 +13140,11 @@ function validateLintPolicy(productDir) {
     }
     validateTestLintDebtNodeManifest(
       productDir,
-      readManifest(productDir, TEST_LINT_DEBT_NODE_MANIFEST_FILE, TEST_LINT_DEBT_NODE_MANIFEST_KEY)
+      readManifest2(productDir, TEST_LINT_DEBT_NODE_MANIFEST_FILE, TEST_LINT_DEBT_NODE_MANIFEST_KEY)
     );
     validateTestOwnedConstantDebtNodeManifest(
       productDir,
-      readManifest(
+      readManifest2(
         productDir,
         TEST_OWNED_CONSTANT_DEBT_NODE_MANIFEST_FILE,
         TEST_OWNED_CONSTANT_DEBT_NODE_MANIFEST_KEY
@@ -12674,36 +13156,6 @@ function validateLintPolicy(productDir) {
   }
 }
 
-// src/validation/steps/subprocess-output.ts
-var VALIDATION_SUBPROCESS_EVENTS = {
-  CLOSE: "close",
-  DATA: "data",
-  DRAIN: "drain",
-  ERROR: "error"
-};
-var defaultValidationSubprocessOutputStreams = {
-  stdout: process.stdout,
-  stderr: process.stderr
-};
-function forwardValidationSubprocessOutput(child, streams = defaultValidationSubprocessOutputStreams) {
-  child.stdout?.on(VALIDATION_SUBPROCESS_EVENTS.DATA, (chunk) => {
-    forwardChunkWithBackpressure(child.stdout, streams.stdout, chunk);
-  });
-  child.stderr?.on(VALIDATION_SUBPROCESS_EVENTS.DATA, (chunk) => {
-    forwardChunkWithBackpressure(child.stderr, streams.stderr, chunk);
-  });
-}
-function forwardChunkWithBackpressure(source, stream, chunk) {
-  const ready = stream.write(chunk);
-  if (ready || stream.once === void 0 || source === null || source === void 0) {
-    return;
-  }
-  source.pause();
-  stream.once(VALIDATION_SUBPROCESS_EVENTS.DRAIN, () => {
-    source.resume();
-  });
-}
-
 // src/validation/steps/eslint.ts
 var defaultEslintProcessRunner = lifecycleProcessRunner;
 var DEFAULT_ESLINT_CONFIG_FILE = "eslint.config.ts";
@@ -12771,8 +13223,8 @@ async function validateESLint(context, runner = defaultEslintProcessRunner, outp
     scopeConfig: context.scopeConfig
   });
   return new Promise((resolve8) => {
-    const localBin = join29(projectRoot, ...ESLINT_LOCAL_BIN_SEGMENTS);
-    const binary = existsSync5(localBin) ? localBin : "npx";
+    const localBin = join30(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, {
       cwd: projectRoot
@@ -12873,7 +13325,7 @@ async function lintCommand(options) {
 
 // src/validation/literal/index.ts
 import { readFile as readFile9 } from "fs/promises";
-import { isAbsolute as isAbsolute5, relative as relative6, resolve as resolve7 } from "path";
+import { isAbsolute as isAbsolute6, relative as relative7, resolve as resolve7 } from "path";
 
 // src/lib/file-inclusion/predicates/ignore-source.ts
 var IGNORE_SOURCE_LAYER = "ignore-source";
@@ -12907,18 +13359,18 @@ var ignoreSourceLayer = makeLayer(
 );
 
 // src/lib/file-inclusion/pipeline.ts
-import { readdir as readdir7 } from "fs/promises";
-import { join as join30, relative as relative5, sep as sep2 } from "path";
+import { readdir as readdir8 } from "fs/promises";
+import { join as join31, relative as relative6, sep as sep2 } from "path";
 var EXPLICIT_OVERRIDE_LAYER = "explicit-override";
-function isNodeError3(err) {
+function isNodeError4(err) {
   return err instanceof Error && "code" in err;
 }
 async function collectPaths(absoluteDir, projectRoot, result, artifactDirs) {
   let dirEntries;
   try {
-    dirEntries = await readdir7(absoluteDir, { withFileTypes: true });
+    dirEntries = await readdir8(absoluteDir, { withFileTypes: true });
   } catch (err) {
-    if (isNodeError3(err) && (err.code === "ENOENT" || err.code === "ENOTDIR")) {
+    if (isNodeError4(err) && (err.code === "ENOENT" || err.code === "ENOTDIR")) {
       return;
     }
     throw err;
@@ -12926,11 +13378,11 @@ async function collectPaths(absoluteDir, projectRoot, result, artifactDirs) {
   for (const entry of dirEntries) {
     if (entry.isDirectory()) {
       if (artifactDirs.has(entry.name)) continue;
-      const absolutePath = join30(absoluteDir, entry.name);
+      const absolutePath = join31(absoluteDir, entry.name);
       await collectPaths(absolutePath, projectRoot, result, artifactDirs);
     } else if (entry.isFile()) {
-      const absolutePath = join30(absoluteDir, entry.name);
-      const rel = relative5(projectRoot, absolutePath);
+      const absolutePath = join31(absoluteDir, entry.name);
+      const rel = relative6(projectRoot, absolutePath);
       result.push(sep2 === "/" ? rel : rel.split(sep2).join("/"));
     }
   }
@@ -13336,8 +13788,8 @@ async function validateLiteralReuse(input) {
   const config = input.config ?? literalConfigDescriptor.defaults;
   const request = input.files ? {
     explicit: input.files.map((f) => {
-      const abs = isAbsolute5(f) ? f : resolve7(input.productDir, f);
-      return relative6(input.productDir, abs).split(/[\\/]/g).join("/");
+      const abs = isAbsolute6(f) ? f : resolve7(input.productDir, f);
+      return relative7(input.productDir, abs).split(/[\\/]/g).join("/");
     })
   } : { walkRoot: input.productDir };
   const scope2 = await runPipeline(
@@ -13358,7 +13810,7 @@ async function validateLiteralReuse(input) {
   const testOccurrencesByFile = /* @__PURE__ */ new Map();
   const indexedOccurrencesByFile = /* @__PURE__ */ new Map();
   for (const abs of candidateFiles) {
-    const rel = relative6(input.productDir, abs).split(/[\\/]/g).join("/");
+    const rel = relative7(input.productDir, abs).split(/[\\/]/g).join("/");
     const content = await readSafe(abs);
     if (content === null) continue;
     const occurrences = collectLiterals(content, rel, collectOptions);
@@ -13596,23 +14048,23 @@ function formatLoc(loc) {
 }
 
 // src/validation/steps/typescript.ts
-import { existsSync as existsSync6, mkdirSync, rmSync, writeFileSync } from "fs";
+import { existsSync as existsSync7, mkdirSync, rmSync, writeFileSync } from "fs";
 import { mkdtemp as mkdtemp3 } from "fs/promises";
-import { isAbsolute as isAbsolute6, join as join31 } from "path";
+import { isAbsolute as isAbsolute7, join as join32 } from "path";
 var defaultTypeScriptProcessRunner = lifecycleProcessRunner;
 var defaultTypeScriptDeps = {
   mkdtemp: mkdtemp3,
   mkdirSync,
   writeFileSync,
   rmSync,
-  existsSync: existsSync6
+  existsSync: existsSync7
 };
 var TEMPORARY_TSCONFIG_COMPILER_OPTIONS = { noEmit: true };
 var TEMPORARY_TSCONFIG_DIR_PREFIX = "validate-ts-";
 async function createTemporaryTsconfigDir(projectRoot, deps) {
-  const parent = join31(projectRoot, ...TEMPORARY_TSCONFIG_PARENT_SEGMENTS);
+  const parent = join32(projectRoot, ...TEMPORARY_TSCONFIG_PARENT_SEGMENTS);
   deps.mkdirSync(parent, { recursive: true });
-  return deps.mkdtemp(join31(parent, TEMPORARY_TSCONFIG_DIR_PREFIX));
+  return deps.mkdtemp(join32(parent, TEMPORARY_TSCONFIG_DIR_PREFIX));
 }
 function buildTypeScriptArgs(context) {
   const { scope: scope2, configFile } = context;
@@ -13620,11 +14072,11 @@ function buildTypeScriptArgs(context) {
 }
 async function createFileSpecificTsconfig(scope2, files, projectRoot, deps = defaultTypeScriptDeps) {
   const tempDir = await createTemporaryTsconfigDir(projectRoot, deps);
-  const configPath = join31(tempDir, "tsconfig.json");
+  const configPath = join32(tempDir, "tsconfig.json");
   const baseConfigFile = TSCONFIG_FILES[scope2];
-  const absoluteFiles = files.map((file) => isAbsolute6(file) ? file : join31(projectRoot, file));
+  const absoluteFiles = files.map((file) => isAbsolute7(file) ? file : join32(projectRoot, file));
   const tempConfig = {
-    extends: join31(projectRoot, baseConfigFile),
+    extends: join32(projectRoot, baseConfigFile),
     files: absoluteFiles,
     include: [],
     exclude: [],
@@ -13641,11 +14093,11 @@ async function createFileSpecificTsconfig(scope2, files, projectRoot, deps = def
 }
 async function createScopeFilteredTsconfig(scope2, projectRoot, scopeConfig, deps = defaultTypeScriptDeps) {
   const tempDir = await createTemporaryTsconfigDir(projectRoot, deps);
-  const configPath = join31(tempDir, "tsconfig.json");
+  const configPath = join32(tempDir, "tsconfig.json");
   const baseConfigFile = TSCONFIG_FILES[scope2];
-  const toProjectPathPattern = (pattern) => isAbsolute6(pattern) ? pattern : join31(projectRoot, pattern);
+  const toProjectPathPattern = (pattern) => isAbsolute7(pattern) ? pattern : join32(projectRoot, pattern);
   const tempConfig = {
-    extends: join31(projectRoot, baseConfigFile),
+    extends: join32(projectRoot, baseConfigFile),
     include: scopeConfig.filePatterns.map(toProjectPathPattern),
     exclude: scopeConfig.excludePatterns.map(toProjectPathPattern),
     compilerOptions: TEMPORARY_TSCONFIG_COMPILER_OPTIONS
@@ -13673,7 +14125,7 @@ async function validateTypeScript(context, options = {}) {
     const { configPath, cleanup } = await createFileSpecificTsconfig(scope2, files, projectRoot, deps);
     try {
       return await new Promise((resolve8) => {
-        const tscBin = join31(projectRoot, "node_modules", ".bin", "tsc");
+        const tscBin = join32(projectRoot, "node_modules", ".bin", "tsc");
         const tscBinary = deps.existsSync(tscBin) ? tscBin : "npx";
         const tscArgs2 = tscBinary === "npx" ? ["tsc", "--project", configPath] : ["--project", configPath];
         const tscProcess = spawnManagedSubprocess(runner, tscBinary, tscArgs2, {
@@ -13706,7 +14158,7 @@ async function validateTypeScript(context, options = {}) {
       return { success: true, skipped: true };
     }
     const { configPath, cleanup } = await createScopeFilteredTsconfig(scope2, projectRoot, scopeConfig, deps);
-    const tscBin = join31(projectRoot, "node_modules", ".bin", "tsc");
+    const tscBin = join32(projectRoot, "node_modules", ".bin", "tsc");
     tool = deps.existsSync(tscBin) ? tscBin : "npx";
     tscArgs = tool === "npx" ? ["tsc", "--project", configPath] : ["--project", configPath];
     return new Promise((resolve8) => {
@@ -13728,7 +14180,7 @@ async function validateTypeScript(context, options = {}) {
       });
     });
   } else {
-    const tscBin = join31(projectRoot, "node_modules", ".bin", "tsc");
+    const tscBin = join32(projectRoot, "node_modules", ".bin", "tsc");
     tool = deps.existsSync(tscBin) ? tscBin : "npx";
     const rawArgs = buildTypeScriptArgs({ scope: scope2, configFile });
     tscArgs = tool === "npx" ? rawArgs : rawArgs.slice(1);
@@ -13905,11 +14357,12 @@ var typescriptValidationLanguage = {
 
 // src/validation/registry.ts
 var validationRegistry = {
-  languages: [typescriptValidationLanguage, markdownValidationLanguage]
+  languages: [typescriptValidationLanguage, markdownValidationLanguage, formattingValidationLanguage]
 };
-var validationPipelineStages = validationRegistry.languages.flatMap(
-  (language) => language.stages
-);
+function composeValidationPipelineStages(languages) {
+  return languages.flatMap((language) => language.stages);
+}
+var validationPipelineStages = composeValidationPipelineStages(validationRegistry.languages);
 var VALIDATION_PIPELINE_TOTAL_STEPS = validationPipelineStages.length;
 
 // src/commands/validation/format.ts
@@ -13972,7 +14425,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 dirname9, join as join32 } from "path";
+import { dirname as dirname9, join as join33 } from "path";
 var EXIT_OK = 0;
 var EXIT_ERROR = 1;
 var INCLUDE_FIELD = "include";
@@ -13992,7 +14445,7 @@ var productionWriter = {
   async write(filePath, content) {
     const dir = dirname9(filePath);
     const random = randomBytes(RANDOM_TOKEN_BYTES).toString("hex");
-    const tmpPath = join32(dir, `${TEMP_FILE_PREFIX}${random}${TEMP_FILE_SUFFIX}`);
+    const tmpPath = join33(dir, `${TEMP_FILE_PREFIX}${random}${TEMP_FILE_SUFFIX}`);
     await writeFile4(tmpPath, content, "utf8");
     await rename4(tmpPath, filePath);
   }
@@ -14098,6 +14551,10 @@ var validationCliDefinition = {
       alias: "md",
       description: "Validate markdown link integrity and structure"
     },
+    format: {
+      commandName: "format",
+      description: "Check code formatting with dprint"
+    },
     all: {
       commandName: "all",
       description: "Run all validations"
@@ -14278,6 +14735,16 @@ function registerValidationCommands(validationCmd) {
     process.exit(result.exitCode);
   });
   addCommonOptions(markdownCmd);
+  const formatCmd = addValidationSubcommand(validationCmd, subcommands.format).action(async (options) => {
+    const result = await formattingCommand({
+      cwd: process.cwd(),
+      files: options.files,
+      quiet: options.quiet
+    });
+    if (result.output) console.log(result.output);
+    process.exit(result.exitCode);
+  });
+  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 result = await allCommand({
       cwd: process.cwd(),
@@ -14339,6 +14806,10 @@ var WORKTREE_STATUS_FORMAT = {
   JSON: "json",
   TEXT: "text"
 };
+var WORKTREE_STATUS_RENDER = {
+  FREE: "-",
+  RUNNING_PID_PREFIX: "PID "
+};
 async function statusCommand2(options) {
   const multiTargetRequest = options.worktrees !== void 0 && options.worktrees.length > 1;
   const targets = await resolveStatusTargets(options);
@@ -14346,9 +14817,13 @@ async function statusCommand2(options) {
   const records = [];
   for (const target of targets.value) {
     const worktreesDir = await resolveWorktreesDir({ ...options, cwd: target.worktreeRoot });
-    const occupancy = await readOccupancy(worktreesDir, target.name, options.processTable, { fs: options.fs });
-    if (!occupancy.ok) return occupancy;
-    records.push({ worktree: target.name, status: occupancy.value });
+    const claimResult = await readClaim(worktreesDir, target.name, { fs: options.fs });
+    if (!claimResult.ok) return claimResult;
+    const claim = claimResult.value;
+    const status = classifyOccupancy(claim, options.processTable);
+    records.push(
+      status === OCCUPANCY_STATUS.RUNNING && claim !== void 0 ? { worktree: target.name, status, pid: claim.pid, session: claim.sessionId, host: claim.host } : { worktree: target.name, status }
+    );
   }
   return { ok: true, value: renderStatus(records, options.format, multiTargetRequest) };
 }
@@ -14360,10 +14835,13 @@ async function resolveStatusTargets(options) {
     return { ok: true, value: [target.value] };
   }
   const targets = [];
+  const seenRoots = /* @__PURE__ */ new Set();
   let firstError;
   for (const worktree of requested) {
     const target = await resolveTargetWorktree({ ...options, worktree });
     if (target.ok) {
+      if (seenRoots.has(target.value.worktreeRoot)) continue;
+      seenRoots.add(target.value.worktreeRoot);
       targets.push(target.value);
     } else {
       firstError ??= target.error;
@@ -14381,7 +14859,10 @@ function renderStatus(records, format2, multiTargetRequest) {
   return records.map(renderTextStatus).join("\n");
 }
 function renderTextStatus(record6) {
-  return `${record6.worktree} ${record6.status}`;
+  if (record6.status === OCCUPANCY_STATUS.RUNNING) {
+    return `${record6.worktree} ${WORKTREE_STATUS_RENDER.RUNNING_PID_PREFIX}${record6.pid} (${record6.session} @ ${record6.host})`;
+  }
+  return `${record6.worktree} ${WORKTREE_STATUS_RENDER.FREE}`;
 }
 
 // src/lib/worktree-path-info.ts
@@ -14429,7 +14910,7 @@ function registerWorktreeCommands(worktreeCmd) {
     });
     if (!result.ok) handleError3(result.error);
   });
-  worktreeCmd.command(`${WORKTREE_CLI.STATUS} ${WORKTREE_CLI.WORKTREE_ARGUMENT}`).description("Report a worktree's occupancy (occupied | unclaimed | stale)").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) => {
+  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: process.cwd(),
       fs: defaultOccupancyFileSystem,