@massu/core 1.1.0 → 1.2.0

package/dist/cli.js

@@ -22570,6 +22570,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 +22671,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 +22824,7 @@ var init_config_refresh = __esm({
     "use strict";
     init_detect();
     init_drift();
+    init_passthrough();
     init_init();
     PRESERVED_FIELDS = [
       "rules",
@@ -22738,7 +22842,8 @@ var init_config_refresh = __esm({
       "cloud",
       "conventions",
       "autoLearning",
-      "python"
+      "python",
+      "toolPrefix"
     ];
   }
 });
@@ -22849,6 +22954,7 @@ 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 ?? [];
@@ -22862,13 +22968,16 @@ function migrateV1ToV2(v1Config, detection) {
   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 +22987,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,6 +23028,7 @@ 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;
@@ -22918,6 +23039,7 @@ var PRESERVED_FIELDS2;
 var init_migrate = __esm({
   "src/detect/migrate.ts"() {
     "use strict";
+    init_passthrough();
     PRESERVED_FIELDS2 = [
       "rules",
       "domains",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@massu/core",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "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/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,6 +191,9 @@ 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.
   let pathsSource: string = typeof v1Paths.source === 'string' ? v1Paths.source : 'src';
@@ -207,16 +211,24 @@ export function migrateV1ToV2(
   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 +241,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 +298,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).

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;
+}