@massu/core 1.1.0 → 1.2.1

package/dist/cli.js

@@ -414,6 +414,7 @@ var init_config = __esm({
     PathsConfigSchema = z.object({
       source: z.string().default("src"),
       aliases: z.record(z.string(), z.string()).default({ "@": "src" }),
+      monorepo_roots: z.array(z.string()).optional(),
       routers: z.string().optional(),
       routerRoot: z.string().optional(),
       pages: z.string().optional(),
@@ -9022,6 +9023,13 @@ import { resolve as resolve4 } from "path";
 function extsFor(language) {
   return EXTENSIONS[language] ?? [];
 }
+function extsWithFallback(language, fallbackTsForJs) {
+  const base = extsFor(language);
+  if (language === "javascript" && fallbackTsForJs) {
+    return [...base, "ts", "tsx"];
+  }
+  return base;
+}
 function isTestPath(language, path) {
   const segments = path.split("/");
   for (const seg of segments) {
@@ -9043,10 +9051,11 @@ function isInsideRoot(root, candidate) {
     return false;
   }
 }
-function detectSourceDirs(projectRoot, languages) {
+function detectSourceDirs(projectRoot, languages, opts) {
+  const fallbackTsForJs = opts?.fallbackTsForJs ?? false;
   const out = {};
   for (const lang of languages) {
-    const exts = extsFor(lang);
+    const exts = extsWithFallback(lang, fallbackTsForJs);
     if (exts.length === 0) continue;
     const patterns = exts.map((e2) => `**/*.${e2}`);
     let files;
@@ -9644,8 +9653,9 @@ async function runDetection(projectRoot, overrides) {
   const languages = Array.from(
     new Set(pkg.manifests.map((m3) => m3.language))
   );
+  const fallbackTsForJs = languages.includes("javascript") && !languages.includes("typescript");
   const [sourceDirs, monorepo] = await Promise.all([
-    Promise.resolve(detectSourceDirs(projectRoot, languages)),
+    Promise.resolve(detectSourceDirs(projectRoot, languages, { fallbackTsForJs })),
     Promise.resolve(detectMonorepo(projectRoot))
   ]);
   const domains = inferDomains(projectRoot, monorepo, sourceDirs);
@@ -10978,6 +10988,9 @@ function detectPython(projectRoot) {
   return result;
 }
 function generateConfig(projectRoot, framework) {
+  console.warn(
+    "[@massu/core] generateConfig() is deprecated since 1.2.1 \u2014 use buildConfigFromDetection instead. It cannot produce valid configs for monorepos."
+  );
   const configPath = resolve5(projectRoot, "massu.config.yaml");
   if (existsSync8(configPath)) {
     return false;
@@ -11028,6 +11041,20 @@ ${yamlStringify(config)}`;
   writeFileSync2(configPath, yamlContent, "utf-8");
   return true;
 }
+function monorepoCommonRoot(packages) {
+  const roots = monorepoDistinctRoots(packages);
+  return roots.length === 1 ? roots[0] : ".";
+}
+function monorepoDistinctRoots(packages) {
+  const set = /* @__PURE__ */ new Set();
+  for (const p19 of packages) {
+    const parts = p19.path.split("/");
+    if (parts.length > 1 && parts[0] !== "" && parts[0] !== ".") {
+      set.add(parts[0]);
+    }
+  }
+  return [...set].sort();
+}
 function buildConfigFromDetection(opts) {
   const { projectRoot, detection } = opts;
   if (!detection) {
@@ -11072,6 +11099,16 @@ function buildConfigFromDetection(opts) {
     const primaryDirs = detection.sourceDirs[primary]?.source_dirs ?? [];
     if (primaryDirs.length > 0) {
       pathsSource = primaryDirs[0];
+    } else if (detection.monorepo.type !== "single" && detection.monorepo.packages.length > 0) {
+      pathsSource = monorepoCommonRoot(detection.monorepo.packages);
+    }
+  }
+  let monorepoRoots;
+  if (detection.monorepo.type !== "single") {
+    if (detection.monorepo.packages.length > 0) {
+      monorepoRoots = monorepoDistinctRoots(detection.monorepo.packages);
+    } else if (pathsSource !== "src" && pathsSource !== ".") {
+      monorepoRoots = [pathsSource];
     }
   }
   const verification = {};
@@ -11108,6 +11145,13 @@ function buildConfigFromDetection(opts) {
   if (Object.keys(languageEntries).length > 0) {
     frameworkBlock.languages = languageEntries;
   }
+  const pathsBlock = {
+    source: pathsSource,
+    aliases: { "@": pathsSource }
+  };
+  if (monorepoRoots && monorepoRoots.length > 0) {
+    pathsBlock.monorepo_roots = monorepoRoots;
+  }
   const config = {
     schema_version: 2,
     project: {
@@ -11115,10 +11159,7 @@ function buildConfigFromDetection(opts) {
       root: "auto"
     },
     framework: frameworkBlock,
-    paths: {
-      source: pathsSource,
-      aliases: { "@": pathsSource }
-    },
+    paths: pathsBlock,
     toolPrefix: "massu",
     domains,
     rules: []
@@ -11225,6 +11266,15 @@ function validateWrittenConfig(configPath, projectRoot, checkPaths = true) {
             }
           }
         }
+        const mRoots = cfg.paths.monorepo_roots;
+        if (Array.isArray(mRoots)) {
+          for (const r2 of mRoots) {
+            if (typeof r2 !== "string" || r2 === ".") continue;
+            if (!existsSync8(resolve5(projectRoot, r2))) {
+              return `paths.monorepo_roots '${r2}' does not exist on disk`;
+            }
+          }
+        }
       }
     } catch (err) {
       return err instanceof Error ? err.message : String(err);
@@ -22570,6 +22620,48 @@ var init_server = __esm({
   }
 });
 
+// src/detect/passthrough.ts
+function copyUnknownKeys(source, target, handledKeys) {
+  if (source === null || typeof source !== "object" || Array.isArray(source)) {
+    return;
+  }
+  for (const k3 of Object.keys(source)) {
+    if (UNSAFE_KEYS.has(k3)) continue;
+    if (source[k3] === void 0) continue;
+    if (handledKeys.has(k3)) continue;
+    if (Object.prototype.hasOwnProperty.call(target, k3)) continue;
+    target[k3] = safeClone(source[k3]);
+  }
+}
+function preserveNestedSubkeys(sourceBlock, targetBlock) {
+  if (sourceBlock === null || sourceBlock === void 0 || typeof sourceBlock !== "object" || Array.isArray(sourceBlock)) {
+    return;
+  }
+  const src = sourceBlock;
+  for (const k3 of Object.keys(src)) {
+    if (UNSAFE_KEYS.has(k3)) continue;
+    if (src[k3] === void 0) continue;
+    if (Object.prototype.hasOwnProperty.call(targetBlock, k3)) continue;
+    targetBlock[k3] = safeClone(src[k3]);
+  }
+}
+function safeClone(v3) {
+  if (typeof structuredClone === "function") {
+    try {
+      return structuredClone(v3);
+    } catch {
+    }
+  }
+  return v3;
+}
+var UNSAFE_KEYS;
+var init_passthrough = __esm({
+  "src/detect/passthrough.ts"() {
+    "use strict";
+    UNSAFE_KEYS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
+  }
+});
+
 // src/commands/config-refresh.ts
 var config_refresh_exports = {};
 __export(config_refresh_exports, {
@@ -22629,6 +22721,67 @@ function mergeRefresh(existing, refreshed) {
       out[field] = existing[field];
     }
   }
+  if (typeof existing.toolPrefix === "string" && existing.toolPrefix !== "") {
+    out.toolPrefix = existing.toolPrefix;
+  }
+  for (const block of ["framework", "paths", "project"]) {
+    const existingBlock = existing[block];
+    const outBlock = out[block];
+    if (existingBlock && typeof existingBlock === "object" && !Array.isArray(existingBlock) && outBlock && typeof outBlock === "object" && !Array.isArray(outBlock)) {
+      preserveNestedSubkeys(existingBlock, outBlock);
+    }
+  }
+  const existingProject = existing.project;
+  const outProject = out.project;
+  if (existingProject && typeof existingProject === "object" && !Array.isArray(existingProject) && outProject && typeof outProject === "object" && !Array.isArray(outProject)) {
+    const userRoot = existingProject.root;
+    if (typeof userRoot === "string" && userRoot !== "") {
+      outProject.root = userRoot;
+    }
+  }
+  const existingPaths = existing.paths;
+  const outPaths = out.paths;
+  if (existingPaths && typeof existingPaths === "object" && !Array.isArray(existingPaths) && outPaths && typeof outPaths === "object" && !Array.isArray(outPaths)) {
+    const existingAliases = existingPaths.aliases;
+    const outAliases = outPaths.aliases;
+    if (existingAliases && typeof existingAliases === "object" && !Array.isArray(existingAliases) && outAliases && typeof outAliases === "object" && !Array.isArray(outAliases)) {
+      outPaths.aliases = {
+        ...outAliases,
+        ...existingAliases
+      };
+    } else if (existingAliases && typeof existingAliases === "object" && !Array.isArray(existingAliases)) {
+      outPaths.aliases = existingAliases;
+    }
+  }
+  const existingVer = existing.verification;
+  const outVer = out.verification;
+  if (existingVer && typeof existingVer === "object" && !Array.isArray(existingVer) && outVer && typeof outVer === "object" && !Array.isArray(outVer)) {
+    const eVer = existingVer;
+    const oVer = outVer;
+    for (const lang of Object.keys(eVer)) {
+      const userLang = eVer[lang];
+      if (userLang === void 0) continue;
+      if (!(lang in oVer)) {
+        oVer[lang] = userLang;
+      } else if (userLang && typeof userLang === "object" && !Array.isArray(userLang) && oVer[lang] && typeof oVer[lang] === "object" && !Array.isArray(oVer[lang])) {
+        oVer[lang] = {
+          ...oVer[lang],
+          ...userLang
+        };
+      }
+    }
+  }
+  const handledTopLevel = /* @__PURE__ */ new Set([
+    "schema_version",
+    "project",
+    "framework",
+    "paths",
+    "toolPrefix",
+    "verification",
+    "detection",
+    ...PRESERVED_FIELDS
+  ]);
+  copyUnknownKeys(existing, out, handledTopLevel);
   return out;
 }
 function renderDiff(diff) {
@@ -22721,6 +22874,7 @@ var init_config_refresh = __esm({
     "use strict";
     init_detect();
     init_drift();
+    init_passthrough();
     init_init();
     PRESERVED_FIELDS = [
       "rules",
@@ -22738,7 +22892,8 @@ var init_config_refresh = __esm({
       "cloud",
       "conventions",
       "autoLearning",
-      "python"
+      "python",
+      "toolPrefix"
     ];
   }
 });
@@ -22849,26 +23004,38 @@ function migrateV1ToV2(v1Config, detection) {
   if (Object.keys(languageEntries).length > 0) {
     framework.languages = languageEntries;
   }
+  preserveNestedSubkeys(v1Framework, framework);
   let pathsSource = typeof v1Paths.source === "string" ? v1Paths.source : "src";
   if (pathsSource === "src" && primary) {
     const primaryDirs = detection.sourceDirs[primary]?.source_dirs ?? [];
-    if (primaryDirs.length > 0) pathsSource = primaryDirs[0];
+    if (primaryDirs.length > 0) {
+      pathsSource = primaryDirs[0];
+    } else if (detection.monorepo?.type !== void 0 && detection.monorepo.type !== "single" && detection.monorepo.packages.length > 0) {
+      pathsSource = monorepoCommonRootMigrate(detection.monorepo.packages);
+    }
   }
   const aliases = v1Paths.aliases && typeof v1Paths.aliases === "object" ? v1Paths.aliases : { "@": pathsSource };
   const paths = {
     source: pathsSource,
     aliases
   };
+  if (detection.monorepo?.type !== void 0 && detection.monorepo.type !== "single" && detection.monorepo.packages.length > 0 && !("monorepo_roots" in v1Paths)) {
+    const roots = monorepoDistinctRootsMigrate(detection.monorepo.packages);
+    if (roots.length > 0) paths.monorepo_roots = roots;
+  }
   for (const k3 of ["routers", "routerRoot", "pages", "middleware", "schema", "components", "hooks"]) {
     if (typeof v1Paths[k3] === "string") paths[k3] = v1Paths[k3];
   }
+  preserveNestedSubkeys(v1Paths, paths);
   const verification = buildVerificationBlock(detection, v1Verification);
+  const project = {
+    name: typeof v1Project.name === "string" ? v1Project.name : "my-project",
+    root: typeof v1Project.root === "string" ? v1Project.root : "auto"
+  };
+  preserveNestedSubkeys(v1Project, project);
   const v22 = {
     schema_version: 2,
-    project: {
-      name: typeof v1Project.name === "string" ? v1Project.name : "my-project",
-      root: typeof v1Project.root === "string" ? v1Project.root : "auto"
-    },
+    project,
     framework,
     paths,
     toolPrefix: typeof v1.toolPrefix === "string" ? v1.toolPrefix : "massu"
@@ -22878,6 +23045,17 @@ function migrateV1ToV2(v1Config, detection) {
       v22[field] = v1[field];
     }
   }
+  const handledTopLevel = /* @__PURE__ */ new Set([
+    "schema_version",
+    "project",
+    "framework",
+    "paths",
+    "toolPrefix",
+    "verification",
+    "python",
+    ...PRESERVED_FIELDS2
+  ]);
+  copyUnknownKeys(v1, v22, handledTopLevel);
   if (!Array.isArray(v22.domains)) {
     v22.domains = [];
   }
@@ -22908,16 +23086,32 @@ function migrateV1ToV2(v1Config, detection) {
     } else if (existing.orm !== void 0) {
       pythonBlock.orm = existing.orm;
     }
+    preserveNestedSubkeys(v1.python, pythonBlock);
     v22.python = pythonBlock;
   } else if (v1.python !== void 0) {
     v22.python = v1.python;
   }
   return v22;
 }
+function monorepoCommonRootMigrate(packages) {
+  const roots = monorepoDistinctRootsMigrate(packages);
+  return roots.length === 1 ? roots[0] : ".";
+}
+function monorepoDistinctRootsMigrate(packages) {
+  const set = /* @__PURE__ */ new Set();
+  for (const p19 of packages) {
+    const parts = p19.path.split("/");
+    if (parts.length > 1 && parts[0] !== "" && parts[0] !== ".") {
+      set.add(parts[0]);
+    }
+  }
+  return [...set].sort();
+}
 var PRESERVED_FIELDS2;
 var init_migrate = __esm({
   "src/detect/migrate.ts"() {
     "use strict";
+    init_passthrough();
     PRESERVED_FIELDS2 = [
       "rules",
       "domains",

package/dist/hooks/auto-learning-pipeline.js

@@ -226,6 +226,7 @@ var PythonConfigSchema = z.object({
 var PathsConfigSchema = z.object({
   source: z.string().default("src"),
   aliases: z.record(z.string(), z.string()).default({ "@": "src" }),
+  monorepo_roots: z.array(z.string()).optional(),
   routers: z.string().optional(),
   routerRoot: z.string().optional(),
   pages: z.string().optional(),

package/dist/hooks/classify-failure.js

@@ -226,6 +226,7 @@ var PythonConfigSchema = z.object({
 var PathsConfigSchema = z.object({
   source: z.string().default("src"),
   aliases: z.record(z.string(), z.string()).default({ "@": "src" }),
+  monorepo_roots: z.array(z.string()).optional(),
   routers: z.string().optional(),
   routerRoot: z.string().optional(),
   pages: z.string().optional(),

package/dist/hooks/cost-tracker.js

@@ -226,6 +226,7 @@ var PythonConfigSchema = z.object({
 var PathsConfigSchema = z.object({
   source: z.string().default("src"),
   aliases: z.record(z.string(), z.string()).default({ "@": "src" }),
+  monorepo_roots: z.array(z.string()).optional(),
   routers: z.string().optional(),
   routerRoot: z.string().optional(),
   pages: z.string().optional(),

package/dist/hooks/fix-detector.js

@@ -226,6 +226,7 @@ var PythonConfigSchema = z.object({
 var PathsConfigSchema = z.object({
   source: z.string().default("src"),
   aliases: z.record(z.string(), z.string()).default({ "@": "src" }),
+  monorepo_roots: z.array(z.string()).optional(),
   routers: z.string().optional(),
   routerRoot: z.string().optional(),
   pages: z.string().optional(),

package/dist/hooks/incident-pipeline.js

@@ -225,6 +225,7 @@ var PythonConfigSchema = z.object({
 var PathsConfigSchema = z.object({
   source: z.string().default("src"),
   aliases: z.record(z.string(), z.string()).default({ "@": "src" }),
+  monorepo_roots: z.array(z.string()).optional(),
   routers: z.string().optional(),
   routerRoot: z.string().optional(),
   pages: z.string().optional(),

package/dist/hooks/post-edit-context.js

@@ -224,6 +224,7 @@ var PythonConfigSchema = z.object({
 var PathsConfigSchema = z.object({
   source: z.string().default("src"),
   aliases: z.record(z.string(), z.string()).default({ "@": "src" }),
+  monorepo_roots: z.array(z.string()).optional(),
   routers: z.string().optional(),
   routerRoot: z.string().optional(),
   pages: z.string().optional(),

package/dist/hooks/post-tool-use.js

@@ -226,6 +226,7 @@ var PythonConfigSchema = z.object({
 var PathsConfigSchema = z.object({
   source: z.string().default("src"),
   aliases: z.record(z.string(), z.string()).default({ "@": "src" }),
+  monorepo_roots: z.array(z.string()).optional(),
   routers: z.string().optional(),
   routerRoot: z.string().optional(),
   pages: z.string().optional(),

package/dist/hooks/pre-compact.js

@@ -226,6 +226,7 @@ var PythonConfigSchema = z.object({
 var PathsConfigSchema = z.object({
   source: z.string().default("src"),
   aliases: z.record(z.string(), z.string()).default({ "@": "src" }),
+  monorepo_roots: z.array(z.string()).optional(),
   routers: z.string().optional(),
   routerRoot: z.string().optional(),
   pages: z.string().optional(),

package/dist/hooks/pre-delete-check.js

@@ -225,6 +225,7 @@ var PythonConfigSchema = z.object({
 var PathsConfigSchema = z.object({
   source: z.string().default("src"),
   aliases: z.record(z.string(), z.string()).default({ "@": "src" }),
+  monorepo_roots: z.array(z.string()).optional(),
   routers: z.string().optional(),
   routerRoot: z.string().optional(),
   pages: z.string().optional(),

package/dist/hooks/quality-event.js

@@ -226,6 +226,7 @@ var PythonConfigSchema = z.object({
 var PathsConfigSchema = z.object({
   source: z.string().default("src"),
   aliases: z.record(z.string(), z.string()).default({ "@": "src" }),
+  monorepo_roots: z.array(z.string()).optional(),
   routers: z.string().optional(),
   routerRoot: z.string().optional(),
   pages: z.string().optional(),

package/dist/hooks/rule-enforcement-pipeline.js

@@ -224,6 +224,7 @@ var PythonConfigSchema = z.object({
 var PathsConfigSchema = z.object({
   source: z.string().default("src"),
   aliases: z.record(z.string(), z.string()).default({ "@": "src" }),
+  monorepo_roots: z.array(z.string()).optional(),
   routers: z.string().optional(),
   routerRoot: z.string().optional(),
   pages: z.string().optional(),

package/dist/hooks/session-end.js

@@ -226,6 +226,7 @@ var PythonConfigSchema = z.object({
 var PathsConfigSchema = z.object({
   source: z.string().default("src"),
   aliases: z.record(z.string(), z.string()).default({ "@": "src" }),
+  monorepo_roots: z.array(z.string()).optional(),
   routers: z.string().optional(),
   routerRoot: z.string().optional(),
   pages: z.string().optional(),

package/dist/hooks/session-start.js

@@ -6002,6 +6002,7 @@ var PythonConfigSchema = z.object({
 var PathsConfigSchema = z.object({
   source: z.string().default("src"),
   aliases: z.record(z.string(), z.string()).default({ "@": "src" }),
+  monorepo_roots: z.array(z.string()).optional(),
   routers: z.string().optional(),
   routerRoot: z.string().optional(),
   pages: z.string().optional(),
@@ -8263,6 +8264,13 @@ var TEST_DIR_KEYWORDS = ["tests", "test", "__tests__", "spec", "specs"];
 function extsFor(language) {
   return EXTENSIONS[language] ?? [];
 }
+function extsWithFallback(language, fallbackTsForJs) {
+  const base = extsFor(language);
+  if (language === "javascript" && fallbackTsForJs) {
+    return [...base, "ts", "tsx"];
+  }
+  return base;
+}
 function isTestPath(language, path) {
   const segments = path.split("/");
   for (const seg of segments) {
@@ -8284,10 +8292,11 @@ function isInsideRoot(root, candidate) {
     return false;
   }
 }
-function detectSourceDirs(projectRoot, languages) {
+function detectSourceDirs(projectRoot, languages, opts) {
+  const fallbackTsForJs = opts?.fallbackTsForJs ?? false;
   const out = {};
   for (const lang of languages) {
-    const exts = extsFor(lang);
+    const exts = extsWithFallback(lang, fallbackTsForJs);
     if (exts.length === 0) continue;
     const patterns = exts.map((e) => `**/*.${e}`);
     let files;
@@ -8808,8 +8817,9 @@ async function runDetection(projectRoot, overrides) {
   const languages = Array.from(
     new Set(pkg.manifests.map((m) => m.language))
   );
+  const fallbackTsForJs = languages.includes("javascript") && !languages.includes("typescript");
   const [sourceDirs, monorepo] = await Promise.all([
-    Promise.resolve(detectSourceDirs(projectRoot, languages)),
+    Promise.resolve(detectSourceDirs(projectRoot, languages, { fallbackTsForJs })),
     Promise.resolve(detectMonorepo(projectRoot))
   ]);
   const domains = inferDomains(projectRoot, monorepo, sourceDirs);

package/dist/hooks/user-prompt.js

@@ -226,6 +226,7 @@ var PythonConfigSchema = z.object({
 var PathsConfigSchema = z.object({
   source: z.string().default("src"),
   aliases: z.record(z.string(), z.string()).default({ "@": "src" }),
+  monorepo_roots: z.array(z.string()).optional(),
   routers: z.string().optional(),
   routerRoot: z.string().optional(),
   pages: z.string().optional(),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@massu/core",
-  "version": "1.1.0",
+  "version": "1.2.1",
   "type": "module",
   "description": "AI Engineering Governance MCP Server - Session memory, knowledge system, feature registry, code intelligence, rule enforcement, tiered tooling (12 free / 72 total), 55+ workflow commands, 11 agents, 20+ patterns",
   "main": "src/server.ts",

package/src/commands/config-refresh.ts

@@ -29,6 +29,7 @@ import { parse as parseYaml } from 'yaml';
 import { runDetection } from '../detect/index.ts';
 import { computeFingerprint } from '../detect/drift.ts';
 import type { AnyConfig } from '../detect/migrate.ts';
+import { copyUnknownKeys, preserveNestedSubkeys } from '../detect/passthrough.ts';
 import { buildConfigFromDetection, renderConfigYaml, writeConfigAtomic } from './init.ts';
 
 const PRESERVED_FIELDS = [
@@ -48,6 +49,7 @@ const PRESERVED_FIELDS = [
   'conventions',
   'autoLearning',
   'python',
+  'toolPrefix',
 ] as const;
 
 export interface ConfigRefreshOptions {
@@ -116,12 +118,113 @@ export function computeDiff(before: AnyConfig, after: AnyConfig): DiffLine[] {
 }
 
 export function mergeRefresh(existing: AnyConfig, refreshed: AnyConfig): AnyConfig {
+  // P1-008: Start from detector output (fresh framework, paths.source, verification, detection).
   const out: AnyConfig = { ...refreshed };
+
+  // Restore user-authored top-level sections verbatim.
   for (const field of PRESERVED_FIELDS) {
     if (existing[field] !== undefined) {
       out[field] = existing[field];
     }
   }
+
+  // Restore toolPrefix from existing (never let detector-defaulted 'massu' overwrite a custom prefix).
+  if (typeof existing.toolPrefix === 'string' && existing.toolPrefix !== '') {
+    out.toolPrefix = existing.toolPrefix;
+  }
+
+  // For detector-owned blocks (framework, paths, project), preserve any user subkey the detector didn't emit.
+  for (const block of ['framework', 'paths', 'project'] as const) {
+    const existingBlock = existing[block];
+    const outBlock = out[block];
+    if (
+      existingBlock && typeof existingBlock === 'object' && !Array.isArray(existingBlock) &&
+      outBlock && typeof outBlock === 'object' && !Array.isArray(outBlock)
+    ) {
+      preserveNestedSubkeys(existingBlock, outBlock as Record<string, unknown>);
+    }
+  }
+
+  // Restore user-set project.root (detector at init.ts:418 always writes 'auto'; user value wins).
+  // Separated from the block loop above for readability (A-004 architecture-review follow-up).
+  const existingProject = existing.project;
+  const outProject = out.project;
+  if (
+    existingProject && typeof existingProject === 'object' && !Array.isArray(existingProject) &&
+    outProject && typeof outProject === 'object' && !Array.isArray(outProject)
+  ) {
+    const userRoot = (existingProject as Record<string, unknown>).root;
+    if (typeof userRoot === 'string' && userRoot !== '') {
+      (outProject as Record<string, unknown>).root = userRoot;
+    }
+  }
+
+  // paths.aliases is a 2-level-nested user block. Detector always writes
+  // { '@': <source-dir> }; user-authored alias map must survive. Spread user
+  // over detector so user keys win for any overlap AND user-only keys survive.
+  // (P5-002 discovery — hedge's paths.aliases['@'] was being overwritten.)
+  const existingPaths = existing.paths;
+  const outPaths = out.paths;
+  if (
+    existingPaths && typeof existingPaths === 'object' && !Array.isArray(existingPaths) &&
+    outPaths && typeof outPaths === 'object' && !Array.isArray(outPaths)
+  ) {
+    const existingAliases = (existingPaths as Record<string, unknown>).aliases;
+    const outAliases = (outPaths as Record<string, unknown>).aliases;
+    if (
+      existingAliases && typeof existingAliases === 'object' && !Array.isArray(existingAliases) &&
+      outAliases && typeof outAliases === 'object' && !Array.isArray(outAliases)
+    ) {
+      (outPaths as Record<string, unknown>).aliases = {
+        ...(outAliases as Record<string, unknown>),
+        ...(existingAliases as Record<string, unknown>),
+      };
+    } else if (existingAliases && typeof existingAliases === 'object' && !Array.isArray(existingAliases)) {
+      (outPaths as Record<string, unknown>).aliases = existingAliases;
+    }
+  }
+
+  // verification is the other 2-level-nested detector-owned block. Semantics
+  // mirror migrate.ts:132-138 buildVerificationBlock: user's custom language
+  // sections (e.g., hedge's `gateway`, `ios`, `runtime`, `web`) survive
+  // wholesale; user's command overrides on shared languages (e.g., `python`)
+  // win over detector defaults. (P5-002 discovery — hedge was losing 15
+  // verification command entries across 4 custom language sections plus
+  // having 4 python commands overwritten with detector defaults.)
+  const existingVer = existing.verification;
+  const outVer = out.verification;
+  if (
+    existingVer && typeof existingVer === 'object' && !Array.isArray(existingVer) &&
+    outVer && typeof outVer === 'object' && !Array.isArray(outVer)
+  ) {
+    const eVer = existingVer as Record<string, unknown>;
+    const oVer = outVer as Record<string, unknown>;
+    for (const lang of Object.keys(eVer)) {
+      const userLang = eVer[lang];
+      if (userLang === undefined) continue;
+      if (!(lang in oVer)) {
+        // User-custom language (no detector counterpart) → preserve wholesale.
+        oVer[lang] = userLang;
+      } else if (
+        userLang && typeof userLang === 'object' && !Array.isArray(userLang) &&
+        oVer[lang] && typeof oVer[lang] === 'object' && !Array.isArray(oVer[lang])
+      ) {
+        // Shared language → user commands win over detector defaults (spread).
+        oVer[lang] = {
+          ...(oVer[lang] as Record<string, unknown>),
+          ...(userLang as Record<string, unknown>),
+        };
+      }
+    }
+  }
+
+  // Preserve top-level user keys not handled above (mirrors P1-001 passthrough for upgrade).
+  const handledTopLevel = new Set<string>([
+    'schema_version', 'project', 'framework', 'paths', 'toolPrefix', 'verification', 'detection',
+    ...PRESERVED_FIELDS,
+  ]);
+  copyUnknownKeys(existing, out, handledTopLevel);
+
   return out;
 }
 

package/src/commands/init.ts

@@ -231,7 +231,18 @@ export function detectPython(projectRoot: string): PythonDetection {
 // Legacy Config File Generation (preserved for cli.test.ts)
 // ============================================================
 
+/**
+ * @deprecated Since @massu/core@1.2.1. Use {@link buildConfigFromDetection}
+ * with {@link runDetection} for monorepo-aware path resolution and
+ * schema_version=2 output. This path hardcodes `paths.source = 'src'` and
+ * cannot emit `paths.monorepo_roots`, so it would roll back on every
+ * non-`src/` layout. Kept only for the legacy `cli.test.ts` smoke tests;
+ * new callers must use the v2 builder.
+ */
 export function generateConfig(projectRoot: string, framework: FrameworkDetection): boolean {
+  console.warn(
+    '[@massu/core] generateConfig() is deprecated since 1.2.1 — use buildConfigFromDetection instead. It cannot produce valid configs for monorepos.'
+  );
   const configPath = resolve(projectRoot, 'massu.config.yaml');
 
   if (existsSync(configPath)) {
@@ -294,6 +305,37 @@ ${yamlStringify(config)}`;
 // V2 Config Builder (detection-driven)
 // ============================================================
 
+/**
+ * Return the common top-level parent directory across every workspace
+ * package. Returns `'.'` when packages span multiple parents (e.g. a repo
+ * with both `apps/*` and `packages/*`) — the project root is always a valid
+ * paths.source value (see validateWrittenConfig at init.ts:572).
+ */
+function monorepoCommonRoot(
+  packages: ReadonlyArray<{ path: string }>
+): string {
+  const roots = monorepoDistinctRoots(packages);
+  return roots.length === 1 ? roots[0] : '.';
+}
+
+/**
+ * Return the distinct top-level parent directories of every workspace
+ * package (e.g. `['apps', 'packages']` when both are present). Sorted for
+ * determinism. Excludes root-level ('.') workspaces.
+ */
+function monorepoDistinctRoots(
+  packages: ReadonlyArray<{ path: string }>
+): string[] {
+  const set = new Set<string>();
+  for (const p of packages) {
+    const parts = p.path.split('/');
+    if (parts.length > 1 && parts[0] !== '' && parts[0] !== '.') {
+      set.add(parts[0]);
+    }
+  }
+  return [...set].sort();
+}
+
 /**
  * Build a schema_version=2 config object from a DetectionResult.
  *
@@ -364,11 +406,38 @@ export function buildConfigFromDetection(
   const legacyUi = (primaryEntry?.ui as string | undefined) ?? 'none';
 
   // Determine paths.source from primary language's dominant source dir.
+  // P1-003: when the primary language has no detectable source dir AND the
+  // repo is a monorepo, fall back to the common parent of workspace packages
+  // (e.g. 'apps' for turbo + apps/*, 'packages' for pnpm + packages/*). This
+  // prevents the validator from rejecting a nonexistent top-level 'src/' on
+  // monorepo shapes where code actually lives under apps/ or packages/.
   let pathsSource = 'src';
   if (primary) {
     const primaryDirs = detection.sourceDirs[primary]?.source_dirs ?? [];
     if (primaryDirs.length > 0) {
       pathsSource = primaryDirs[0];
+    } else if (
+      detection.monorepo.type !== 'single' &&
+      detection.monorepo.packages.length > 0
+    ) {
+      pathsSource = monorepoCommonRoot(detection.monorepo.packages);
+    }
+  }
+
+  // P1-005: emit `paths.monorepo_roots` as the distinct parent directories of
+  // every workspace package when this is a monorepo. Optional + additive;
+  // v1 consumers ignore it. When detection identified a monorepo type
+  // (turbo/nx/pnpm/etc) but no manifested workspace packages were found
+  // (e.g. fresh-install fixtures with apps/*/main.py that haven't declared
+  // sub-manifests yet), fall back to deriving roots from the resolved
+  // paths.source so the field is still accurate for monorepo-aware tools.
+  let monorepoRoots: string[] | undefined;
+  if (detection.monorepo.type !== 'single') {
+    if (detection.monorepo.packages.length > 0) {
+      monorepoRoots = monorepoDistinctRoots(detection.monorepo.packages);
+    } else if (pathsSource !== 'src' && pathsSource !== '.') {
+      // Derive from paths.source when no workspace manifests exist.
+      monorepoRoots = [pathsSource];
     }
   }
 
@@ -411,6 +480,14 @@ export function buildConfigFromDetection(
     frameworkBlock.languages = languageEntries;
   }
 
+  const pathsBlock: Record<string, unknown> = {
+    source: pathsSource,
+    aliases: { '@': pathsSource },
+  };
+  if (monorepoRoots && monorepoRoots.length > 0) {
+    pathsBlock.monorepo_roots = monorepoRoots;
+  }
+
   const config: Record<string, unknown> = {
     schema_version: 2,
     project: {
@@ -418,10 +495,7 @@ export function buildConfigFromDetection(
       root: 'auto',
     },
     framework: frameworkBlock,
-    paths: {
-      source: pathsSource,
-      aliases: { '@': pathsSource },
-    },
+    paths: pathsBlock,
     toolPrefix: 'massu',
     domains,
     rules: [],
@@ -588,6 +662,17 @@ export function validateWrittenConfig(
             }
           }
         }
+        // P2-001: verify paths.monorepo_roots entries exist on disk (parity
+        // with paths.source existence check at line 624-631 above).
+        const mRoots = (cfg.paths as Record<string, unknown>).monorepo_roots;
+        if (Array.isArray(mRoots)) {
+          for (const r of mRoots) {
+            if (typeof r !== 'string' || r === '.') continue;
+            if (!existsSync(resolve(projectRoot, r))) {
+              return `paths.monorepo_roots '${r}' does not exist on disk`;
+            }
+          }
+        }
       }
     } catch (err) {
       return err instanceof Error ? err.message : String(err);

package/src/config.ts

@@ -254,9 +254,14 @@ const PythonConfigSchema = z.object({
 export type PythonConfig = z.infer<typeof PythonConfigSchema>;
 
 // --- Paths Config ---
+// `monorepo_roots` (P1-005): optional, additive. Emitted by `init --ci` when
+// `monorepo.type !== 'single'` and at least one workspace package exists.
+// Downstream tools may consume it for monorepo-aware scanning. Existing v1
+// configs omit it — `.optional()` preserves full back-compat.
 const PathsConfigSchema = z.object({
   source: z.string().default('src'),
   aliases: z.record(z.string(), z.string()).default({ '@': 'src' }),
+  monorepo_roots: z.array(z.string()).optional(),
   routers: z.string().optional(),
   routerRoot: z.string().optional(),
   pages: z.string().optional(),

package/src/detect/index.ts

@@ -135,9 +135,18 @@ export async function runDetection(
     new Set(pkg.manifests.map((m) => m.language))
   ) as SupportedLanguage[];
 
+  // P1-002: when the repo has a `javascript` manifest but NO `typescript`
+  // manifest, still glob `.ts`/`.tsx` for the javascript slot. This fixes
+  // plain-JS monorepos (e.g. turbo + next in a package.json with no
+  // `typescript` dep and no `tsconfig.json`) that contain `.tsx` files
+  // under `apps/*/`. Without this, `init --ci` falls back to the nonexistent
+  // `src/` and rolls back with a validation error.
+  const fallbackTsForJs =
+    languages.includes('javascript') && !languages.includes('typescript');
+
   // 3b. run source-dir + monorepo detection in parallel (both pure fs).
   const [sourceDirs, monorepo] = await Promise.all([
-    Promise.resolve(detectSourceDirs(projectRoot, languages)),
+    Promise.resolve(detectSourceDirs(projectRoot, languages, { fallbackTsForJs })),
     Promise.resolve(detectMonorepo(projectRoot)),
   ]);
 

package/src/detect/migrate.ts

@@ -22,6 +22,7 @@
  */
 
 import type { DetectionResult, SupportedLanguage, VRCommandSet } from './index.ts';
+import { copyUnknownKeys, preserveNestedSubkeys } from './passthrough.ts';
 
 /**
  * Shape accepted for input. We intentionally use `Record<string, unknown>`
@@ -190,12 +191,26 @@ export function migrateV1ToV2(
   if (Object.keys(languageEntries).length > 0) {
     framework.languages = languageEntries;
   }
+  // P1-004: preserve any v1Framework subkey the explicit rebuild didn't emit
+  // (e.g., hedge's `framework.{python, rust, swift, typescript}` language sub-blocks).
+  preserveNestedSubkeys(v1Framework, framework);
 
   // Paths: preserve user-set fields; fill `source` from detection if user had 'src' default.
+  // P1-003 (mirror of init.ts:367-390): when primary language has no source dir
+  // AND this is a monorepo, fall back to the common parent of workspace packages
+  // instead of leaving the nonexistent default 'src' in place.
   let pathsSource: string = typeof v1Paths.source === 'string' ? v1Paths.source : 'src';
   if (pathsSource === 'src' && primary) {
     const primaryDirs = detection.sourceDirs[primary]?.source_dirs ?? [];
-    if (primaryDirs.length > 0) pathsSource = primaryDirs[0];
+    if (primaryDirs.length > 0) {
+      pathsSource = primaryDirs[0];
+    } else if (
+      detection.monorepo?.type !== undefined &&
+      detection.monorepo.type !== 'single' &&
+      detection.monorepo.packages.length > 0
+    ) {
+      pathsSource = monorepoCommonRootMigrate(detection.monorepo.packages);
+    }
   }
   const aliases = v1Paths.aliases && typeof v1Paths.aliases === 'object'
     ? (v1Paths.aliases as Record<string, string>)
@@ -204,19 +219,38 @@ export function migrateV1ToV2(
     source: pathsSource,
     aliases,
   };
+  // P1-005 mirror: emit monorepo_roots for upgraded v2 configs (additive,
+  // only when monorepo + not already user-specified).
+  if (
+    detection.monorepo?.type !== undefined &&
+    detection.monorepo.type !== 'single' &&
+    detection.monorepo.packages.length > 0 &&
+    !('monorepo_roots' in v1Paths)
+  ) {
+    const roots = monorepoDistinctRootsMigrate(detection.monorepo.packages);
+    if (roots.length > 0) paths.monorepo_roots = roots;
+  }
   for (const k of ['routers', 'routerRoot', 'pages', 'middleware', 'schema', 'components', 'hooks']) {
     if (typeof v1Paths[k] === 'string') paths[k] = v1Paths[k];
   }
+  // P1-005: preserve any v1Paths subkey the explicit rebuild didn't emit
+  // (e.g., hedge's 19 custom `paths.*` entries like adr, plans, monorepo_root).
+  preserveNestedSubkeys(v1Paths, paths);
 
   const verification = buildVerificationBlock(detection, v1Verification);
 
+  // P1-006: build project block with nested passthrough so custom subkeys
+  // (e.g., hedge's `project.description`) survive the migration.
+  const project: Record<string, unknown> = {
+    name: typeof v1Project.name === 'string' ? v1Project.name : 'my-project',
+    root: typeof v1Project.root === 'string' ? v1Project.root : 'auto',
+  };
+  preserveNestedSubkeys(v1Project, project);
+
   // Construct v2 output.
   const v2: AnyConfig = {
     schema_version: 2,
-    project: {
-      name: typeof v1Project.name === 'string' ? v1Project.name : 'my-project',
-      root: typeof v1Project.root === 'string' ? v1Project.root : 'auto',
-    },
+    project,
     framework,
     paths,
     toolPrefix: typeof v1.toolPrefix === 'string' ? v1.toolPrefix : 'massu',
@@ -229,6 +263,24 @@ export function migrateV1ToV2(
     }
   }
 
+  // P1-001: preserve any v1 top-level key not already handled by the explicit
+  // migrator. This is the generalization of PRESERVED_FIELDS — custom sections
+  // like `services`, `workflow`, `north_stars` (hedge) now pass through.
+  //
+  // `detection` is intentionally NOT in handledTopLevel: when a v2 config is
+  // fed back in (idempotence check at migrate.ts:16), the existing `detection`
+  // block round-trips via this passthrough path. It gets re-stamped with a
+  // fresh fingerprint by the caller at config-upgrade.ts:96-99 right after
+  // migrateV1ToV2 returns. Any future v2-only top-level key added here must
+  // either appear in this list (with explicit handling above) or round-trip
+  // through this passthrough — never add a v2-only key that does neither.
+  // (A-006 architecture-review follow-up.)
+  const handledTopLevel = new Set<string>([
+    'schema_version', 'project', 'framework', 'paths', 'toolPrefix',
+    'verification', 'python', ...PRESERVED_FIELDS,
+  ]);
+  copyUnknownKeys(v1, v2, handledTopLevel);
+
   // Ensure domains / rules exist as arrays (v2 requires them).
   if (!Array.isArray(v2.domains)) {
     v2.domains = [];
@@ -268,6 +320,9 @@ export function migrateV1ToV2(
     } else if (existing.orm !== undefined) {
       pythonBlock.orm = existing.orm;
     }
+    // P1-007: preserve any v1 python subkey not already handled above
+    // (e.g., `python.test_framework`, `python.database`).
+    preserveNestedSubkeys(v1.python, pythonBlock);
     v2.python = pythonBlock;
   } else if (v1.python !== undefined) {
     // Preserve even if detection didn't find python (e.g. non-monorepo-with-python).
@@ -276,3 +331,32 @@ export function migrateV1ToV2(
 
   return v2;
 }
+
+/**
+ * Return the common top-level parent directory across every workspace
+ * package (mirror of init.ts:monorepoCommonRoot). Returns `'.'` when
+ * packages span multiple parents.
+ */
+function monorepoCommonRootMigrate(
+  packages: ReadonlyArray<{ path: string }>
+): string {
+  const roots = monorepoDistinctRootsMigrate(packages);
+  return roots.length === 1 ? roots[0] : '.';
+}
+
+/**
+ * Return the distinct top-level parent directories of every workspace
+ * package (mirror of init.ts:monorepoDistinctRoots). Sorted for determinism.
+ */
+function monorepoDistinctRootsMigrate(
+  packages: ReadonlyArray<{ path: string }>
+): string[] {
+  const set = new Set<string>();
+  for (const p of packages) {
+    const parts = p.path.split('/');
+    if (parts.length > 1 && parts[0] !== '' && parts[0] !== '.') {
+      set.add(parts[0]);
+    }
+  }
+  return [...set].sort();
+}

package/src/detect/passthrough.ts

@@ -0,0 +1,108 @@
+// Copyright (c) 2026 Massu. All rights reserved.
+// Licensed under BSL 1.1 - see LICENSE file for details.
+
+/**
+ * Shared passthrough helpers for config migration + refresh.
+ *
+ * These helpers exist to prevent the class of bug fixed in @massu/core@1.2.0
+ * (incident 2026-04-19-config-upgrade-data-loss): a hand-maintained allow-list
+ * in `migrate.ts` silently dropped any v1 top-level key not on the list, and
+ * the parallel rebuild blocks inside `framework` / `paths` / `project` /
+ * `python` did the same thing at the nested level.
+ *
+ * Both helpers are TARGET-WINS: the migrator writes the keys it actively owns,
+ * then the helper fills in everything else the user had. A user-authored value
+ * in `target` is NEVER overwritten by the source.
+ *
+ * Why two exports instead of one:
+ *   - `copyUnknownKeys` takes an explicit `handledKeys` set — used for TOP-LEVEL
+ *     passthrough where the caller enumerates the keys it migrated explicitly
+ *     (e.g., schema_version, project, framework, paths, toolPrefix, …).
+ *   - `preserveNestedSubkeys` takes no handled-set — used for NESTED passthrough
+ *     where the target block was just rebuilt, so `k in target` already skips
+ *     any key the rebuild populated. Splitting the two makes callsites
+ *     self-documenting without a verbose `new Set()` argument at every nested
+ *     call (A-002 architecture-review follow-up).
+ */
+
+/** Keys that would mutate Object.prototype if copied as own properties. Explicit
+ *  denylist defense-in-depth on top of the existing `k in target` guard and the
+ *  `yaml@2.8` parser's non-polluting behavior (S-001 security-review follow-up). */
+const UNSAFE_KEYS: ReadonlySet<string> = new Set(['__proto__', 'constructor', 'prototype']);
+
+/**
+ * Copy any key from `source` into `target` that target doesn't already have set,
+ * skipping keys listed in `handledKeys`. Target values ALWAYS win — this function
+ * never overwrites an existing target key.
+ *
+ * - If source[k] is undefined → skip (undefined is not a preservable value).
+ * - If k is an UNSAFE_KEYS entry → skip (prototype-pollution defense).
+ * - If handledKeys.has(k) → skip (caller has its own handling).
+ * - If target already owns k → skip (target wins).
+ * - Otherwise → target[k] = deepClone(source[k]).
+ *
+ * Values are DEEP-CLONED via structuredClone so that mutating the output v2
+ * object never reaches back into the v1 input (S-002 security-review follow-up).
+ * Preserves the migrator's "pure data in, pure data out" contract.
+ */
+export function copyUnknownKeys(
+  source: Record<string, unknown>,
+  target: Record<string, unknown>,
+  handledKeys: ReadonlySet<string>
+): void {
+  if (source === null || typeof source !== 'object' || Array.isArray(source)) {
+    return;
+  }
+  for (const k of Object.keys(source)) {
+    if (UNSAFE_KEYS.has(k)) continue;
+    if (source[k] === undefined) continue;
+    if (handledKeys.has(k)) continue;
+    if (Object.prototype.hasOwnProperty.call(target, k)) continue;
+    target[k] = safeClone(source[k]);
+  }
+}
+
+/**
+ * Preserve every subkey from sourceBlock into targetBlock that targetBlock
+ * doesn't already have. Target values ALWAYS win.
+ *
+ * If sourceBlock is not a plain object (string, array, null, undefined),
+ * return early — there are no subkeys to preserve. This matches the coercion
+ * semantics of `getRecord` in migrate.ts and prevents throws on loose v1 inputs
+ * like `framework: "typescript"`.
+ *
+ * Values are deep-cloned (see copyUnknownKeys); UNSAFE_KEYS are skipped.
+ */
+export function preserveNestedSubkeys(
+  sourceBlock: unknown,
+  targetBlock: Record<string, unknown>
+): void {
+  if (
+    sourceBlock === null ||
+    sourceBlock === undefined ||
+    typeof sourceBlock !== 'object' ||
+    Array.isArray(sourceBlock)
+  ) {
+    return;
+  }
+  const src = sourceBlock as Record<string, unknown>;
+  for (const k of Object.keys(src)) {
+    if (UNSAFE_KEYS.has(k)) continue;
+    if (src[k] === undefined) continue;
+    if (Object.prototype.hasOwnProperty.call(targetBlock, k)) continue;
+    targetBlock[k] = safeClone(src[k]);
+  }
+}
+
+/** structuredClone with a fallback for environments without it (Node <17). */
+function safeClone<T>(v: T): T {
+  if (typeof structuredClone === 'function') {
+    try {
+      return structuredClone(v);
+    } catch {
+      // structuredClone throws on functions, DOM nodes, etc. — YAML never produces
+      // those, but if a caller passes something exotic, fall through to shallow.
+    }
+  }
+  return v;
+}

package/src/detect/source-dir-detector.ts

@@ -109,6 +109,25 @@ function extsFor(language: SupportedLanguage): string[] {
   return EXTENSIONS[language] ?? [];
 }
 
+/**
+ * Extensions for a language, with optional fallback for javascript-only repos
+ * that still contain `.ts`/`.tsx` files (no `typescript` manifest, no
+ * `tsconfig.json`). Fixes the bug where `apps/web/page.tsx` in a plain-JS
+ * monorepo is invisible to the javascript glob, causing `init --ci` to fall
+ * back to the nonexistent `src/`. See plan item P1-001 and incident
+ * `2026-04-20-massu-core-monorepo-paths-source.md`.
+ */
+function extsWithFallback(
+  language: SupportedLanguage,
+  fallbackTsForJs: boolean
+): string[] {
+  const base = extsFor(language);
+  if (language === 'javascript' && fallbackTsForJs) {
+    return [...base, 'ts', 'tsx'];
+  }
+  return base;
+}
+
 function isTestPath(language: SupportedLanguage, path: string): boolean {
   // Any dedicated test-dir keyword in the path segments
   const segments = path.split('/');
@@ -144,14 +163,21 @@ function isInsideRoot(root: string, candidate: string): boolean {
  *
  * @param projectRoot absolute path to repo root
  * @param languages   list of languages to probe (derived from P1-001 manifests)
+ * @param opts        optional flags:
+ *   - `fallbackTsForJs`: when true AND the language is `javascript` AND no
+ *     `typescript` manifest was discovered, also glob `.ts`/`.tsx`. This is
+ *     the P1-001 fix for plain-JS monorepos (e.g. turbo with `next` in a
+ *     package.json that lacks a typescript dep) that still use `.tsx`.
  */
 export function detectSourceDirs(
   projectRoot: string,
-  languages: SupportedLanguage[]
+  languages: SupportedLanguage[],
+  opts?: { fallbackTsForJs?: boolean }
 ): SourceDirMap {
+  const fallbackTsForJs = opts?.fallbackTsForJs ?? false;
   const out: SourceDirMap = {};
   for (const lang of languages) {
-    const exts = extsFor(lang);
+    const exts = extsWithFallback(lang, fallbackTsForJs);
     if (exts.length === 0) continue;
     const patterns = exts.map((e) => `**/*.${e}`);
     let files: string[];