universal-dev-standards 6.10.0 → 6.11.0

package/src/utils/integration-generator.js

@@ -3,8 +3,10 @@ import { dirname, join, basename } from 'path';
 import { getLanguageRules } from '../prompts/integrations.js';
 import { computeIntegrationBlockHash } from './hasher.js';
 import { UDS_MARKERS, SUPPORTED_AI_TOOLS, LEGACY_TOOL_MAPPINGS } from '../core/constants.js';
+import { locateMarkerBlock } from './marker-locator.js';
 import { resolveSelectedOptionSources, resolveStandardFilename, getAllStandards } from './registry.js';
 import { getAgentConfig, getAgentTier } from '../config/ai-agent-paths.js';
+import { STANDARD_ID_MAPPING } from './conversion-rules.js';
 
 /**
  * Resolve contentMode and level based on AI tool's tier and capabilities.
@@ -2746,6 +2748,81 @@ function generateWorkflowGateContent(language) {
  * @param {Object} config - Integration configuration
  * @returns {string} Generated content
  */
+/**
+ * Strip a standard's extension to get its bare identifying stem, e.g.
+ * 'commit-message.ai.yaml' -> 'commit-message'. Shared by
+ * resolveStandardReferences and getHeadingToPrimaryStandardStem below.
+ */
+function stemOf(value) {
+  return basename(String(value)).replace(/\.(ai\.yaml|yaml|md)$/i, '');
+}
+
+/**
+ * Normalize a Markdown ATX heading line for comparison, e.g.
+ * '## 提交訊息標準  ' -> '提交訊息標準'. Returns null for a non-heading line.
+ */
+function normalizeHeadingLine(line) {
+  const m = String(line).match(/^#{1,6}\s+(.+?)\s*$/);
+  return m ? m[1].trim() : null;
+}
+
+let _headingToPrimaryStandardStem = null;
+
+/**
+ * Map every RULE_TEMPLATES section heading (any category, detail level,
+ * language that has a Reference:/參考: line) to the stem of the FIRST
+ * `.standards/...` path on that line — that section's "primary standard".
+ *
+ * XSPEC adopter-report, narrow auto-repair (decision 1, 2026-09-18):
+ * 6.10.0's resolveStandardReferences deleted `.standards/commit-message-guide.md`
+ * from an existing file's "## 提交訊息標準" section — it looked exactly like a
+ * retired, uninstalled UDS standard — leaving only the trailing options
+ * reference behind. Rewriting away the resulting dangling comma (the earlier
+ * fix, same XSPEC) does not bring the deleted item back: it is gone from the
+ * file, and nothing else regenerates that section, because rule-template
+ * sections live OUTSIDE the UDS markers by design.
+ *
+ * This map is how resolveStandardReferences recognizes "this heading belongs
+ * to a UDS rule template, and here is the one reference it must never be
+ * missing" — so it can restore ONLY that single item, ONLY when it is
+ * genuinely installed and missing from the line. A heading that does not
+ * match any template (a user's own section) is simply absent from this map,
+ * so it is never touched.
+ *
+ * Computed once and cached — RULE_TEMPLATES is a static module constant.
+ *
+ * @returns {Map<string, string>} heading text (without leading '#'s) -> primary standard stem
+ */
+function getHeadingToPrimaryStandardStem() {
+  if (_headingToPrimaryStandardStem) return _headingToPrimaryStandardStem;
+
+  const map = new Map();
+  const refLineRe = /^(?:Reference|參考|参考)[:：]([^\n]*)$/im;
+
+  for (const categoryTemplates of Object.values(RULE_TEMPLATES)) {
+    for (const modeTemplates of Object.values(categoryTemplates)) {
+      for (const text of Object.values(modeTemplates)) {
+        const heading = normalizeHeadingLine(String(text).split('\n')[0]);
+        if (!heading) continue;
+
+        // 'minimal' mode has no Reference: line at all — nothing to repair,
+        // and no primary standard to record for that heading.
+        const refMatch = text.match(refLineRe);
+        if (!refMatch) continue;
+
+        const firstItem = refMatch[1].split(',')[0].trim();
+        const pathMatch = firstItem.match(/^\.standards\/([^\s,`)\]]+)$/);
+        if (!pathMatch) continue;
+
+        map.set(heading, stemOf(pathMatch[1]));
+      }
+    }
+  }
+
+  _headingToPrimaryStandardStem = map;
+  return map;
+}
+
 /**
  * Point every `.standards/<file>` reference at the file this project actually has.
  *
@@ -2769,7 +2846,6 @@ function generateWorkflowGateContent(language) {
 function resolveStandardReferences(content, installedStandards = [], standardsFormat = 'ai', projectPath = null) {
   if (!content) return content;
 
-  const stemOf = (value) => basename(String(value)).replace(/\.(ai\.yaml|yaml|md)$/i, '');
   // Every stem UDS itself ships — the only references this function may delete.
   //
   // Read defensively: this runs inside pure content generation, and callers
@@ -2796,15 +2872,68 @@ function resolveStandardReferences(content, installedStandards = [], standardsFo
     installedByStem.set(stemOf(filename), filename);
   }
 
-  const referenceLine = /^([^\n]*(?:Reference|參考|参考)[:：])([^\n]*)$/gim;
-  return content.replace(referenceLine, (line, label, rest) => {
-    let dropped = 0;
-    let kept = 0;
-    const rewritten = rest.replace(/(\.standards\/)([^\s,`)\]]+)/g, (match, prefix, path) => {
+  // XSPEC adopter-report Q2: a reference written against a pre-6.0.0
+  // filename (`commit-message-guide.md`) must still resolve to whatever this
+  // project installed under the CURRENT id (`commit-message`) — that rename
+  // is exactly what STANDARD_ID_MAPPING already records, previously
+  // consulted only by the human→AI YAML generator. Without it, the old name
+  // was indistinguishable from a retired, UDS-owned standard the project
+  // chose not to install, and got deleted instead of rewritten.
+  const resolveActualFilename = (path) => {
+    const stem = stemOf(path);
+    return installedByStem.get(stem) || installedByStem.get(STANDARD_ID_MAPPING[stem] || stem) || null;
+  };
+
+  const headingToPrimaryStem = getHeadingToPrimaryStandardStem();
+  const headingLineRe = /^#{1,6}\s+/;
+  const referenceLineRe = /^([^\n]*(?:Reference|參考|参考)[:：])([^\n]*)$/i;
+
+  // XSPEC adopter-report Q2: rebuilt as a line-by-line split → filter → join
+  // instead of a single global regex, so each "Reference:" line's PRECEDING
+  // heading is known (needed for decision 1's narrow auto-repair below) —
+  // and instead of patching a deleted substring's separators with more
+  // regexes. The old single-regex approach deleted only the matched
+  // `.standards/...` text in place and then tried to tidy up whatever
+  // punctuation was left around the hole; it handled a trailing comma, a
+  // doubled comma, and a comma with stray space, but not a comma left
+  // dangling right after the colon when the FIRST item was the one dropped
+  // (`Reference:, .standards/other.md`).
+  const lines = content.split('\n');
+  let currentHeading = null;
+  const outLines = [];
+
+  for (const rawLine of lines) {
+    if (headingLineRe.test(rawLine)) {
+      currentHeading = normalizeHeadingLine(rawLine);
+      outLines.push(rawLine);
+      continue;
+    }
+
+    const refMatch = rawLine.match(referenceLineRe);
+    if (!refMatch) {
+      outLines.push(rawLine);
+      continue;
+    }
+
+    const [, label, rest] = refMatch;
+    const items = rest.split(',').map((s) => s.trim()).filter(Boolean);
+    const kept = [];
+    const presentStems = new Set();
+
+    for (const item of items) {
+      const pathMatch = item.match(/^(\.standards\/)([^\s,`)\]]+)$/);
+      if (!pathMatch) {
+        // Not a bare `.standards/...` reference (e.g. trailing prose) — leave untouched.
+        kept.push(item);
+        continue;
+      }
+      const [, prefix, path] = pathMatch;
+
       // Option files live in `.standards/options/…` and are named by path, not ID.
-      if (path.startsWith('options/')) { kept++; return match; }
-      const actual = installedByStem.get(stemOf(path));
-      if (actual) { kept++; return `${prefix}${actual}`; }
+      if (path.startsWith('options/')) { kept.push(item); presentStems.add(stemOf(path)); continue; }
+
+      const actual = resolveActualFilename(path);
+      if (actual) { kept.push(`${prefix}${actual}`); presentStems.add(stemOf(actual)); continue; }
 
       // 🔴 Only UDS's own standards may be dropped. The first version of this
       // rewrite removed every unmatched reference, which deleted a project's own
@@ -2816,14 +2945,38 @@ function resolveStandardReferences(content, installedStandards = [], standardsFo
       } catch {
         onDisk = false;
       }
-      if (onDisk || !udsOwnedStems.has(stemOf(path))) { kept++; return match; }
-      dropped++;
-      return '';
-    });
-    if (kept === 0 && dropped > 0) return '';
-    // Tidy the separators left behind by a dropped path.
-    return `${label}${rewritten.replace(/,\s*,/g, ',').replace(/[:：]?\s*,\s*$/, '').replace(/\s+,/g, ',')}`;
-  }).replace(/\n{3,}/g, '\n\n');
+      if (onDisk || !udsOwnedStems.has(stemOf(path))) {
+        kept.push(item);
+        presentStems.add(stemOf(path));
+        continue;
+      }
+      // Dropped: a UDS-owned reference to a standard this project did not install.
+    }
+
+    // XSPEC adopter-report, narrow auto-repair (decision 1): this line's
+    // heading matches a UDS rule template EXACTLY (see
+    // getHeadingToPrimaryStandardStem's docblock) and that template's
+    // primary standard is genuinely installed but missing from the line —
+    // put it back at the front. Idempotent: a line that already has it does
+    // nothing. Everything else about the line — the project's own entries,
+    // options files, existing order — is untouched, and no OTHER (secondary)
+    // template item is ever added back.
+    const primaryStem = currentHeading ? headingToPrimaryStem.get(currentHeading) : null;
+    if (primaryStem && !presentStems.has(primaryStem)) {
+      const primaryActual = installedByStem.get(primaryStem);
+      if (primaryActual) {
+        kept.unshift(`.standards/${primaryActual}`);
+      }
+    }
+
+    if (kept.length === 0) {
+      outLines.push('');
+      continue;
+    }
+    outLines.push(`${label} ${kept.join(', ')}`);
+  }
+
+  return outLines.join('\n').replace(/\n{3,}/g, '\n\n');
 }
 
 export function generateIntegrationContent(config) {
@@ -3030,7 +3183,10 @@ export function mergeRules(existingContent, newContent, strategy) {
  * @returns {Object} Result with success status
  */
 export function writeIntegrationFile(tool, config, projectPath) {
-  const fileName = getToolFileName(tool);
+  // XSPEC-418 R2/R3: config.integrationTargets carries manifest.integrationTargets
+  // (or its init-time equivalent) through unchanged — this is the actual write path,
+  // so it must be the one place that honors a per-tool target override.
+  const fileName = resolveIntegrationTargetFile(tool, { integrationTargets: config.integrationTargets });
   if (!fileName) {
     return { success: false, error: `Unknown tool: ${tool}` };
   }
@@ -3097,10 +3253,13 @@ export function writeIntegrationFile(tool, config, projectPath) {
  * Check if integration file exists
  * @param {string} tool - Tool name
  * @param {string} projectPath - Project root path
+ * @param {Object} [manifestLike] - Manifest-like object; only `integrationTargets` is
+ *   read (XSPEC-418 R2) — pass the real manifest, or `{ integrationTargets }` at
+ *   init time before a manifest object exists.
  * @returns {boolean} True if file exists
  */
-export function integrationFileExists(tool, projectPath) {
-  const fileName = getToolFileName(tool);
+export function integrationFileExists(tool, projectPath, manifestLike) {
+  const fileName = resolveIntegrationTargetFile(tool, manifestLike);
   return fileName && existsSync(join(projectPath, fileName));
 }
 
@@ -3334,7 +3493,12 @@ export function buildToolIntegrationConfig(manifest, tool) {
     contentMode: resolved.contentMode,
     level: resolved.level,
     outputLanguage: selected,
-    methodology: manifest.methodology
+    methodology: manifest.methodology,
+    // XSPEC-418 R2/R3: threads the per-tool target override through to
+    // writeIntegrationFile via resolveIntegrationTargetFile. Every caller of
+    // this function (regenerateIntegrations, plan-executor's migrate_block,
+    // backfillIntegrationConfigs) gets the override for free.
+    integrationTargets: manifest.integrationTargets
   };
 }
 
@@ -3394,13 +3558,18 @@ export function wrapWithMarkers(content, format) {
  */
 export function extractMarkedContent(fileContent, format) {
   const markers = UDS_MARKERS[format] || UDS_MARKERS.markdown;
-  const startIdx = fileContent.indexOf(markers.start);
-  const endIdx = fileContent.indexOf(markers.end);
-
-  if (startIdx === -1 || endIdx === -1 || endIdx <= startIdx) {
+  // XSPEC adopter-report Q5: locateMarkerBlock requires the marker to occupy
+  // a whole line by itself (and not be inside a fenced code block), so a
+  // sentence that merely mentions the marker text is never mistaken for the
+  // real boundary. It throws AmbiguousMarkerError if more than one real pair
+  // exists — callers must not catch that away silently.
+  const block = locateMarkerBlock(fileContent, markers);
+
+  if (!block) {
     return { before: fileContent, content: '', after: '' };
   }
 
+  const { startIdx, endIdx } = block;
   return {
     before: fileContent.substring(0, startIdx),
     content: fileContent.substring(startIdx + markers.start.length, endIdx).trim(),
@@ -3417,15 +3586,18 @@ export function extractMarkedContent(fileContent, format) {
  */
 export function updateMarkedSection(existingContent, newMarkedContent, format) {
   const markers = UDS_MARKERS[format] || UDS_MARKERS.markdown;
-  const startIdx = existingContent.indexOf(markers.start);
-  const endIdx = existingContent.indexOf(markers.end);
+  // XSPEC adopter-report Q5: same rule as extractMarkedContent — a line that
+  // merely mentions the marker text is not a boundary, so it is never
+  // deleted along with (what used to be mistaken for) "the UDS block".
+  const block = locateMarkerBlock(existingContent, markers);
 
-  if (startIdx === -1 || endIdx === -1) {
+  if (!block) {
     // No existing markers, append new content
     return existingContent.trim() + '\n\n' + wrapWithMarkers(newMarkedContent, format) + '\n';
   }
 
   // Replace existing marked section
+  const { startIdx, endIdx } = block;
   const before = existingContent.substring(0, startIdx);
   const after = existingContent.substring(endIdx + markers.end.length);
 
@@ -3441,6 +3613,45 @@ export function getToolFilePath(tool) {
   return getToolFileName(tool) || null;
 }
 
+/**
+ * Tool × manifest → the integration file this tool actually reads/writes.
+ *
+ * XSPEC-418 R2: honors a per-tool override recorded in
+ * `manifest.integrationTargets` (currently only ever set for `claude-code`, to
+ * `CLAUDE.local.md` — a personal UDS adoption in a repo with a team-owned,
+ * version-controlled `CLAUDE.md`). No override set → same file
+ * `getToolFilePath` already returns, so every manifest that never sets
+ * `integrationTargets` gets byte-identical output (XSPEC-418 AC-5).
+ *
+ * This is the single place "tool → target file" is decided once a manifest (or
+ * a manifest-shaped config carrying `integrationTargets`) is in scope. Every
+ * call site that used to call `getToolFilePath`/`getToolFileName` to answer
+ * "what file do I read/write for this tool right now" must call this instead
+ * — enforced by the static-scan guard in
+ * tests/unit/core/integration-target-resolver-guard.test.js.
+ *
+ * Placed here rather than core/constants.js, where XSPEC-418 originally
+ * suggested it next to `resolveIntegrationFile`: the default-file fallback
+ * must be the `getToolFileName` above — the one with the legacy-mapping guard,
+ * the already-a-filename passthrough, and the "known agent missing from
+ * SUPPORTED_AI_TOOLS" throw (see its own comment) — not a re-implementation in
+ * constants.js, which would silently drop that throw for every call site this
+ * migrates. constants.js is imported BY this file already, so this file
+ * cannot be imported back from constants.js without a cycle; it lives beside
+ * the function it wraps instead.
+ *
+ * @param {string} tool - Tool key (e.g. 'claude-code'), or an entry already
+ *   resolved to a file path — passed straight to `getToolFileName`, which
+ *   already tolerates that shape (XSPEC-208 BUG-208-01).
+ * @param {Object} [manifest] - Manifest-like object; only `integrationTargets` is read.
+ * @returns {string|null} Repo-relative target file, or null for a genuinely unknown tool.
+ */
+export function resolveIntegrationTargetFile(tool, manifest) {
+  const key = LEGACY_TOOL_MAPPINGS[tool] || tool;
+  const override = manifest?.integrationTargets?.[key];
+  if (typeof override === 'string' && override.length > 0) return override;
+  return getToolFileName(tool) || null;
+}
 
 /**
  * Get default commands based on ecosystem

package/src/utils/marker-locator.js

@@ -0,0 +1,140 @@
+/**
+ * Shared marker-block location logic for UDS-managed sections in integration
+ * files (CLAUDE.md, AGENTS.md, etc.).
+ *
+ * XSPEC adopter-report Q5 (v3.5.0–6.10.0): every call site that located the
+ * `<!-- UDS:STANDARDS:START -->` / `<!-- UDS:STANDARDS:END -->` pair used
+ * `content.indexOf(markers.start)` / `.indexOf(markers.end)` directly. That
+ * matches the marker text anywhere in the file — including inside a sentence
+ * that merely *mentions* it (this project's own CLAUDE.md explains the marker
+ * syntax in prose, `<!-- UDS:STANDARDS:START -->`, inline) or inside a fenced
+ * code sample quoting it. A write path built on that wrong index then treated
+ * everything between the mention and the real END marker as "the UDS block"
+ * and deleted it — including the user's own content in between.
+ *
+ * The fix: a marker only counts when, after trimming, it occupies an entire
+ * line by itself, and that line is not inside a fenced code block (``` or
+ * ~~~). Every reader of a marker pair in this codebase must go through
+ * `locateMarkerBlock`/`tryLocateMarkerBlock` instead of indexOf/includes —
+ * enforced by a static-scan guard test.
+ */
+
+/**
+ * @typedef {Object} MarkerLine
+ * @property {number} offset - Character offset of the marker text itself
+ *   within `content` (not the start of the line — leading whitespace before
+ *   the marker, if any, is excluded).
+ * @property {number} line - 1-based line number.
+ */
+
+/**
+ * Find every standalone-line, non-fenced-code occurrence of `markerText`.
+ * @param {string} content
+ * @param {string} markerText
+ * @returns {MarkerLine[]}
+ */
+function findMarkerLines(content, markerText) {
+  const lines = content.split('\n');
+  const occurrences = [];
+  let offset = 0;
+  let inFence = false;
+
+  for (let i = 0; i < lines.length; i++) {
+    const rawLine = lines[i];
+    const trimmed = rawLine.trim();
+
+    if (/^(`{3,}|~{3,})/.test(trimmed)) {
+      // Fenced code block delimiter (``` or ```lang, closing ``` too) — a
+      // marker string appearing between a pair of these is a documentation
+      // sample, not a real boundary. This intentionally does not try to
+      // distinguish open/close by matching fence characters or length; any
+      // triple-backtick-or-tilde line toggles the state, matching how
+      // Markdown renderers treat fences in practice.
+      inFence = !inFence;
+    } else if (!inFence && trimmed === markerText) {
+      const leading = rawLine.length - rawLine.trimStart().length;
+      occurrences.push({ offset: offset + leading, line: i + 1 });
+    }
+
+    offset += rawLine.length + 1; // +1 for the '\n' that split('\n') consumed
+  }
+
+  return occurrences;
+}
+
+/**
+ * Thrown when a marker's start or end text has more than one standalone,
+ * non-fenced occurrence in a file — the file is ambiguous and no caller
+ * should guess which one is the real boundary.
+ */
+export class AmbiguousMarkerError extends Error {
+  /**
+   * @param {string} markerText
+   * @param {number[]} lines - 1-based line numbers of every occurrence found.
+   */
+  constructor(markerText, lines) {
+    super(
+      `Found ${lines.length} standalone occurrences of marker "${markerText}" ` +
+      `on line(s) ${lines.join(', ')} — expected exactly one. Refusing to guess ` +
+      'which one bounds the UDS-managed block.'
+    );
+    this.name = 'AmbiguousMarkerError';
+    this.markerText = markerText;
+    this.lines = lines;
+  }
+}
+
+/**
+ * Locate the single UDS marker block in `content`.
+ *
+ * @param {string} content
+ * @param {{start: string, end: string}} markers
+ * @returns {{startIdx: number, endIdx: number, startLine: number, endLine: number} | null}
+ *   `null` means "this file has no UDS block" — the same meaning the old
+ *   `startIdx === -1` check carried. This is not an error.
+ * @throws {AmbiguousMarkerError} when more than one valid START or END line
+ *   exists — the file has two or more marker pairs, or a corrupted one.
+ */
+export function locateMarkerBlock(content, markers) {
+  const starts = findMarkerLines(content, markers.start);
+  const ends = findMarkerLines(content, markers.end);
+
+  if (starts.length > 1) {
+    throw new AmbiguousMarkerError(markers.start, starts.map((s) => s.line));
+  }
+  if (ends.length > 1) {
+    throw new AmbiguousMarkerError(markers.end, ends.map((e) => e.line));
+  }
+  if (starts.length === 0 || ends.length === 0) {
+    return null;
+  }
+
+  const startIdx = starts[0].offset;
+  const endIdx = ends[0].offset;
+  if (endIdx <= startIdx) {
+    return null;
+  }
+
+  return { startIdx, endIdx, startLine: starts[0].line, endLine: ends[0].line };
+}
+
+/**
+ * Non-throwing variant of `locateMarkerBlock` for callers that must not
+ * crash a broader scan on one ambiguous file (e.g. a full-project state
+ * scan reconciling many files at once). Ambiguity is reported through the
+ * return value instead of an exception.
+ *
+ * @param {string} content
+ * @param {{start: string, end: string}} markers
+ * @returns {{ok: true, block: ReturnType<typeof locateMarkerBlock>} | {ok: false, error: AmbiguousMarkerError}}
+ */
+export function tryLocateMarkerBlock(content, markers) {
+  try {
+    return { ok: true, block: locateMarkerBlock(content, markers) };
+  } catch (error) {
+    if (error instanceof AmbiguousMarkerError) {
+      return { ok: false, error };
+    }
+    throw error;
+  }
+}

package/src/utils/reference-sync.js

@@ -338,7 +338,12 @@ export function calculateCategoriesFromStandards(standards) {
   const categories = new Set();
 
   for (const std of standards) {
-    const category = getStandardCategory(std);
+    // XSPEC adopter-report Q1: getStandardCategory is keyed by filename and
+    // returns null for a bare manifest stem ('commit-message'), which is
+    // exactly what a 3.4.0 manifest stores — this emptied the whole category
+    // set on a real install. categoryForStandard (below) tries the stem
+    // against both known extensions first.
+    const category = categoryForStandard(std);
     if (category) {
       categories.add(category);
     }
@@ -347,6 +352,53 @@ export function calculateCategoriesFromStandards(standards) {
   return Array.from(categories);
 }
 
+/**
+ * Whether a stored `categories` array is broken and should not be trusted:
+ * missing/not-an-array, empty, or containing a value this build does not
+ * recognize as a category id.
+ *
+ * @param {*} categories - `manifest.integrationConfigs[file].categories`
+ * @returns {boolean}
+ */
+function categoriesLookBroken(categories) {
+  if (!Array.isArray(categories) || categories.length === 0) return true;
+  const known = new Set(Object.keys(CATEGORY_TO_STANDARDS));
+  return categories.some((c) => !known.has(c));
+}
+
+/**
+ * Repair `manifest.integrationConfigs[file].categories` wherever it is empty
+ * or contains an unrecognized value, recomputing it from `manifest.standards`
+ * the same way `calculateCategoriesFromStandards` (used by `--sync-refs`)
+ * does.
+ *
+ * XSPEC adopter-report Q1 follow-up (main-session review): the original Q1
+ * fix repaired this only inside `--sync-refs`. A manifest that picked up a
+ * broken `categories: []` from an older buggy `--sync-refs` run stayed
+ * broken forever afterward — a plain `uds update` reaches its OWN,
+ * independent integration-sync code path (update.js's general update flow)
+ * which writes `integrationBlockHashes` but never even reads
+ * `integrationConfigs`, so nothing there ever corrected it. The next `uds
+ * check --restore-missing` then rebuilt the file from that broken stored
+ * config and silently dropped sections. Deliberately conservative: an
+ * already-valid (if outdated) categories list is left alone — that is
+ * `--sync-refs`'s job, not every plain `update`'s — this only self-heals
+ * outright corruption (empty or unrecognized values).
+ *
+ * @param {Object} manifest - Manifest object (mutated in place)
+ * @returns {string[]} Paths whose `categories` were repaired
+ */
+export function repairIntegrationConfigCategories(manifest) {
+  if (!manifest?.integrationConfigs) return [];
+  const repaired = [];
+  for (const [file, config] of Object.entries(manifest.integrationConfigs)) {
+    if (!config || !categoriesLookBroken(config.categories)) continue;
+    config.categories = calculateCategoriesFromStandards(manifest.standards || []);
+    repaired.push(file);
+  }
+  return repaired;
+}
+
 /**
  * Get all standard filenames that should be referenced for given categories
  *

package/standards-registry.json

@@ -1,6 +1,6 @@
 {
   "$schema": "https://json-schema.org/draft/2020-12/schema",
-  "version": "6.10.0",
+  "version": "6.11.0",
   "lastUpdated": "2026-05-13",
   "description": "Standards registry for universal-dev-standards with integrated skills and AI-optimized formats",
   "formats": {
@@ -58,14 +58,14 @@
     "standards": {
       "name": "universal-dev-standards",
       "url": "https://github.com/AsiaOstrich/universal-dev-standards",
-      "version": "6.10.0"
+      "version": "6.11.0"
     },
     "skills": {
       "name": "universal-dev-standards",
       "url": "https://github.com/AsiaOstrich/universal-dev-standards",
       "localPath": "skills",
       "rawUrl": "https://raw.githubusercontent.com/AsiaOstrich/universal-dev-standards/main/skills",
-      "version": "6.10.0",
+      "version": "6.11.0",
       "note": "Skills are now included in the main repository under skills/"
     }
   },
@@ -2283,7 +2283,7 @@
       "id": "license-compliance",
       "name": "License Compliance Standards",
       "nameZh": "授權合規標準",
-      "version": "6.10.0",
+      "version": "6.11.0",
       "source": {
         "human": "core/license-compliance.md",
         "ai": "ai/standards/license-compliance.ai.yaml"
@@ -2295,7 +2295,7 @@
       "id": "verification-oracle",
       "name": "Verification Oracle Standards",
       "nameZh": "驗證 Oracle 標準",
-      "version": "6.10.0",
+      "version": "6.11.0",
       "source": {
         "human": "core/verification-oracle.md",
         "ai": "ai/standards/verification-oracle.ai.yaml"
@@ -2307,7 +2307,7 @@
       "id": "model-provenance",
       "name": "Model Provenance Policy Standards",
       "nameZh": "模型來源政策標準",
-      "version": "6.10.0",
+      "version": "6.11.0",
       "source": {
         "human": "core/model-provenance.md",
         "ai": "ai/standards/model-provenance.ai.yaml"
@@ -2319,7 +2319,7 @@
       "id": "resource-cost-boundary",
       "name": "Resource / Cost Boundary Declaration Standards",
       "nameZh": "資源／成本邊界宣告標準",
-      "version": "6.10.0",
+      "version": "6.11.0",
       "source": {
         "human": "core/resource-cost-boundary.md",
         "ai": "ai/standards/resource-cost-boundary.ai.yaml"