@3fn/core 14.0.0 → 15.0.0

package/application-mcp-server/src/index.ts

@@ -12,7 +12,7 @@ import { Server } from '@modelcontextprotocol/sdk/server/index.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { CallToolRequestSchema, ListToolsRequestSchema } from '@modelcontextprotocol/sdk/types.js';
 
-import { ComponentIndexer } from './indexer/ComponentIndexer';
+import { ComponentIndexer, mutableComponentRoots } from './indexer/ComponentIndexer';
 import { ComponentQueryEngine } from './query/QueryEngine';
 import { AssemblyValidator } from './validation/AssemblyValidator';
 import { FileWatcher } from './watcher/FileWatcher';
@@ -26,7 +26,16 @@ const DEFAULT_TOKEN_INDEX_DIR = 'token-index';
 
 /** Explicit data paths for the Application MCP. All optional — defaults derive from package root. */
 interface DataPaths {
-  componentsDir: string;
+  /**
+   * The component ROOT SET, precedence order — consumer root first, package root last (Spec 123
+   * C3, from `resolveComponentRoots`). A single string is the legacy single-root form.
+   */
+  componentsDir: string | string[];
+  /**
+   * C3 `projectRoot = bornRoot` (unborn → the package root). Omitted → the indexer's legacy
+   * derivation from the package root (single-root callers).
+   */
+  projectRoot?: string;
   patternsDir?: string;
   templatesDir?: string;
   guidanceDir?: string;
@@ -35,15 +44,19 @@ interface DataPaths {
   designLanguagePath?: string;
 }
 
-// Tool definitions
-const tools = [
+// Tool definitions (Spec 123 Task 4, C8: every registration carries an explicit
+// `readOnlyHint` — the manifest and the servers' own approval computation read
+// this array as the registration module, never a hand-maintained list).
+export const tools = [
   {
     name: 'get_component_catalog',
+    annotations: { readOnlyHint: true },
     description: 'Get lightweight catalog of all components with name, type, family, purpose, and readiness. ~50 tokens per component.',
     inputSchema: { type: 'object' as const, properties: {} },
   },
   {
     name: 'get_component_summary',
+    annotations: { readOnlyHint: true },
     description: 'Get component summary: identity, contract categories, token count, annotations. ~200 tokens.',
     inputSchema: {
       type: 'object' as const,
@@ -53,6 +66,7 @@ const tools = [
   },
   {
     name: 'get_component_full',
+    annotations: { readOnlyHint: true },
     description: 'Get complete assembled metadata including all contracts, composition rules, and token relationships.',
     inputSchema: {
       type: 'object' as const,
@@ -62,6 +76,7 @@ const tools = [
   },
   {
     name: 'find_components',
+    annotations: { readOnlyHint: true },
     description: 'Find components by category, concept, platform, purpose keyword, or usage context. Returns ApplicationSummary with promoted selection guidance (purpose, whenToUse, whenNotToUse, alternatives, contexts). All parameters optional and combinable (conjunctive). Use `keyword` for natural-language tokenized discovery (e.g. "primary action button", "login", "text input field").',
     inputSchema: {
       type: 'object' as const,
@@ -78,6 +93,7 @@ const tools = [
   },
   {
     name: 'check_composition',
+    annotations: { readOnlyHint: true },
     description: 'Check if a parent component can contain a child component, with optional prop context.',
     inputSchema: {
       type: 'object' as const,
@@ -91,21 +107,25 @@ const tools = [
   },
   {
     name: 'get_component_health',
+    annotations: { readOnlyHint: true },
     description: 'Get index health: status, component count, pattern count, warnings, gaps.',
     inputSchema: { type: 'object' as const, properties: {} },
   },
   {
     name: 'rebuild_index',
+    annotations: { readOnlyHint: false },
     description: 'Rebuild the component index from scratch. Use when index is stale or out of sync. Returns new health status after reindex.',
     inputSchema: { type: 'object' as const, properties: {} },
   },
   {
     name: 'list_experience_patterns',
+    annotations: { readOnlyHint: true },
     description: 'List all experience patterns with name, description, category, tags, step count, and component count.',
     inputSchema: { type: 'object' as const, properties: {} },
   },
   {
     name: 'get_experience_pattern',
+    annotations: { readOnlyHint: true },
     description: 'Get full experience pattern by name: steps, components with roles and hints, accessibility notes, and alternatives.',
     inputSchema: {
       type: 'object' as const,
@@ -115,11 +135,13 @@ const tools = [
   },
   {
     name: 'list_layout_templates',
+    annotations: { readOnlyHint: true },
     description: 'List all layout templates with name, description, category, tags, and region count.',
     inputSchema: { type: 'object' as const, properties: {} },
   },
   {
     name: 'get_layout_template',
+    annotations: { readOnlyHint: true },
     description: 'Get full layout template by name: regions with grid behavior per breakpoint, stacking rules, and token references.',
     inputSchema: {
       type: 'object' as const,
@@ -129,6 +151,7 @@ const tools = [
   },
   {
     name: 'validate_assembly',
+    annotations: { readOnlyHint: true },
     description: 'Validate a component tree. Checks component existence, parent-child composition rules, requires/count constraints, and assembly-level accessibility (form labels, submit actions, page headings). Returns errors, warnings, and accessibility issues with paths.',
     inputSchema: {
       type: 'object' as const,
@@ -143,6 +166,7 @@ const tools = [
   },
   {
     name: 'get_prop_guidance',
+    annotations: { readOnlyHint: true },
     description: 'Get prop selection and family member guidance for a component or family. Returns whenToUse, whenNotToUse, selectionRules (scenario→recommendation with optional props), accessibilityNotes, and family-scoped patterns. Query by component name (returns its family guidance) or family name.',
     inputSchema: {
       type: 'object' as const,
@@ -156,6 +180,7 @@ const tools = [
   // Token query tools (Spec 096)
   {
     name: 'search_tokens',
+    annotations: { readOnlyHint: true },
     description: 'Search tokens by family, tier (primitive/semantic/component), or name. All parameters optional and combinable.',
     inputSchema: {
       type: 'object' as const,
@@ -168,6 +193,7 @@ const tools = [
   },
   {
     name: 'get_token_details',
+    annotations: { readOnlyHint: true },
     description: 'Get full details for a token: value, family, tier, platform names, formula, theme-varying status, consumers.',
     inputSchema: {
       type: 'object' as const,
@@ -179,6 +205,7 @@ const tools = [
   },
   {
     name: 'get_token_family',
+    annotations: { readOnlyHint: true },
     description: 'Get all tokens in a family across all tiers.',
     inputSchema: {
       type: 'object' as const,
@@ -190,6 +217,7 @@ const tools = [
   },
   {
     name: 'get_token_consumers',
+    annotations: { readOnlyHint: true },
     description: 'Get all components that reference a token.',
     inputSchema: {
       type: 'object' as const,
@@ -201,16 +229,19 @@ const tools = [
   },
   {
     name: 'get_design_philosophy',
+    annotations: { readOnlyHint: true },
     description: 'Get the design system\'s creative north star, aesthetic philosophy, and key characteristics.',
     inputSchema: { type: 'object' as const, properties: {} },
   },
   {
     name: 'get_design_rules',
+    annotations: { readOnlyHint: true },
     description: 'Get named design rules as structured data (name, constraint, rationale).',
     inputSchema: { type: 'object' as const, properties: {} },
   },
   {
     name: 'get_design_guidance',
+    annotations: { readOnlyHint: true },
     description: 'Get design do\'s and don\'ts as categorized directives. Optionally filter by category.',
     inputSchema: {
       type: 'object' as const,
@@ -221,6 +252,7 @@ const tools = [
   },
   {
     name: 'get_color_strategy',
+    annotations: { readOnlyHint: true },
     description: 'Get color strategy vocabulary (Restrained/Committed/Full/Drenched) with usage guidance. Optionally filter by tier.',
     inputSchema: {
       type: 'object' as const,
@@ -250,6 +282,18 @@ export interface TestableServer {
   callTool(name: string, args: Record<string, unknown>): Promise<unknown>;
   /** Index components + tokens so the test server is ready to serve requests. */
   initialize(): Promise<void>;
+  /** Start the server's file watcher (the live server starts it in `start()`). Spec 123 Task 1.4. */
+  startWatching(): void;
+  /** Stop the server's file watcher. */
+  stopWatching(): void;
+  /** The directories the staleness gate scans / the component roots the watcher watches. Spec 123 Task 1.4. */
+  getWatchedDirs(): { stalenessDataDirs: string[]; watchedComponentRoots: string[] };
+}
+
+/** Test-only server options (Spec 123 Task 1.4). */
+export interface TestableServerOptions {
+  /** Staleness-gate threshold; the live server uses the gate's default (30s). */
+  stalenessThresholdMs?: number;
 }
 
 /**
@@ -259,19 +303,18 @@ export interface TestableServer {
  *
  * @param paths - same DataPaths contract as ComponentMCPServer; defaults match real-corpus layout
  */
-export function createTestableServer(paths: DataPaths): TestableServer {
-  const server = new ComponentMCPServer(paths);
+export function createTestableServer(paths: DataPaths, options: TestableServerOptions = {}): TestableServer {
+  const server = new ComponentMCPServer(paths, options);
   return {
-    initialize: () =>
-      server.indexer.indexComponents(
-        paths.componentsDir,
-        paths.patternsDir,
-        paths.templatesDir,
-        paths.guidanceDir,
-        paths.tokenIndexDir,
-      ),
+    initialize: async () => {
+      await server.fullIndex();
+      server.markIndexed();
+    },
     callTool: (name: string, args: Record<string, unknown>) =>
       server.handleTool(name, args),
+    startWatching: () => server.startWatching(),
+    stopWatching: () => server.stopWatching(),
+    getWatchedDirs: () => server.getWatchedDirs(),
   };
 }
 
@@ -283,15 +326,23 @@ class ComponentMCPServer {
   private fileWatcher: FileWatcher;
   private philosophyIndexer: DesignPhilosophyIndexer;
   private stalenessGate: StalenessGate;
+  private readonly stalenessDataDirs: string[];
+  private readonly watchedComponentRoots: string[];
 
-  constructor(private paths: DataPaths) {
+  constructor(private paths: DataPaths, options: TestableServerOptions = {}) {
     this.server = new Server({ name: SERVER_NAME, version: SERVER_VERSION }, { capabilities: { tools: {} } });
     this.indexer = new ComponentIndexer();
     this.queryEngine = new ComponentQueryEngine(this.indexer);
     this.assemblyValidator = new AssemblyValidator(this.indexer);
+
+    // Spec 123 C3: the watcher and the staleness gate watch the CONSUMER root; the package root
+    // is exempt as immutable (it lives under node_modules in every consumer install).
+    const componentRoots = Array.isArray(this.paths.componentsDir) ? this.paths.componentsDir : [this.paths.componentsDir];
+    this.watchedComponentRoots = mutableComponentRoots(componentRoots);
+
     this.fileWatcher = new FileWatcher(
       this.indexer,
-      this.paths.componentsDir,
+      this.watchedComponentRoots,
       this.paths.patternsDir,
       this.paths.templatesDir,
       this.paths.guidanceDir,
@@ -299,26 +350,23 @@ class ComponentMCPServer {
     );
     this.philosophyIndexer = new DesignPhilosophyIndexer();
 
-    const dataDirs = [
-      this.paths.componentsDir,
+    // Every non-component data dir keeps the pre-123 rule: immutable (node_modules) data is not scanned.
+    const otherDirs = [
       this.paths.patternsDir,
       this.paths.templatesDir,
       this.paths.guidanceDir,
       this.paths.tokenIndexDir,
-    ].filter(Boolean) as string[];
+    ].filter((d): d is string => Boolean(d) && !isImmutableContext(d as string));
+    this.stalenessDataDirs = [...this.watchedComponentRoots, ...otherDirs];
 
     this.stalenessGate = new StalenessGate({
-      dataDirs,
+      dataDirs: this.stalenessDataDirs,
       fileExtensions: ['.yaml', '.ts', '.md'],
-      isImmutable: isImmutableContext(this.paths.componentsDir),
+      thresholdMs: options.stalenessThresholdMs,
+      // Nothing mutable to scan (e.g. an unborn consumer: everything is package data) → skip all checks.
+      isImmutable: this.stalenessDataDirs.length === 0,
       onRebuild: async () => {
-        await this.indexer.indexComponents(
-          this.paths.componentsDir,
-          this.paths.patternsDir,
-          this.paths.templatesDir,
-          this.paths.guidanceDir,
-          this.paths.tokenIndexDir
-        );
+        await this.fullIndex();
         if (this.paths.designLanguagePath) {
           await this.philosophyIndexer.index(this.paths.designLanguagePath);
         }
@@ -328,14 +376,43 @@ class ComponentMCPServer {
     this.registerHandlers();
   }
 
-  async start(): Promise<void> {
+  /** Full index over the component root set, anchored on `projectRoot` (C3 `projectRoot = bornRoot`). */
+  async fullIndex(): Promise<void> {
     await this.indexer.indexComponents(
       this.paths.componentsDir,
       this.paths.patternsDir,
       this.paths.templatesDir,
       this.paths.guidanceDir,
-      this.paths.tokenIndexDir
+      this.paths.tokenIndexDir,
+      { projectRoot: this.paths.projectRoot },
     );
+  }
+
+  /** @internal Test seam (Spec 123 Task 1.4). */
+  markIndexed(): void {
+    this.stalenessGate.markIndexed();
+  }
+
+  /** @internal Test seam (Spec 123 Task 1.4). */
+  startWatching(): void {
+    this.fileWatcher.start();
+  }
+
+  /** @internal Test seam (Spec 123 Task 1.4). */
+  stopWatching(): void {
+    this.fileWatcher.stop();
+  }
+
+  /** @internal Test seam (Spec 123 Task 1.4). */
+  getWatchedDirs(): { stalenessDataDirs: string[]; watchedComponentRoots: string[] } {
+    return {
+      stalenessDataDirs: [...this.stalenessDataDirs],
+      watchedComponentRoots: this.fileWatcher.getWatchedComponentRoots(),
+    };
+  }
+
+  async start(): Promise<void> {
+    await this.fullIndex();
     this.fileWatcher.start();
 
     // Token index status (loaded inside indexComponents if tokenIndexDir provided)
@@ -346,9 +423,14 @@ class ComponentMCPServer {
 
     const health = this.indexer.getHealth();
     console.error(`[${SERVER_NAME}] Indexed ${health.componentsIndexed} components (${health.warnings.length} warnings)`);
-    if (!this.paths.tokenIndexDir) {
-      console.error(`[${SERVER_NAME}] Token index not available (Spec 096 pending)`);
-    }
+    // Spec 123 Task 1.6: this line USED TO print a stale, wrong "(Spec 096 pending)"
+    // excuse whenever `tokenIndexDir` was undefined. It fires now for real
+    // birth-detection reasons (a partial refusal, an absent/empty index, an
+    // unreadable explicit TOKEN_INDEX_DIR) — the SPECIFIC catalog-string message for
+    // that reason is already printed earlier, in the `require.main` bootstrap block
+    // (before this server is even constructed). Printing a second, vaguer, wrong-spec
+    // message here would just contradict the accurate one — removed rather than
+    // reworded.
 
     // Design philosophy
     if (this.paths.designLanguagePath) {
@@ -432,13 +514,7 @@ class ComponentMCPServer {
       case 'get_component_health':
         return this.queryEngine.getHealth();
       case 'rebuild_index':
-        await this.indexer.indexComponents(
-          this.paths.componentsDir,
-          this.paths.patternsDir,
-          this.paths.templatesDir,
-          this.paths.guidanceDir,
-          this.paths.tokenIndexDir
-        );
+        await this.fullIndex();
         if (this.paths.designLanguagePath) {
           await this.philosophyIndexer.index(this.paths.designLanguagePath);
         }
@@ -509,22 +585,105 @@ class ComponentMCPServer {
  * runtime. Types are declared locally (shape-only, no logic) so the sub-package
  * typecheck has no dependency on the root dist being built.
  */
-interface ResolvedDataRoot {
+/** Shape-only mirror of `bornRepo.ts`'s `DesignSystemRoot` (Spec 123 Task 1.2) — no logic, avoids a cross-sub-package import. */
+export interface DesignSystemRootShape {
+  state: 'born' | 'package-mode' | 'partial' | 'unborn';
+  root: string | null;
+  tierDir: string | null;
+  partialCase?: 'config-no-tier' | 'unused-local-tier' | 'tier-no-config' | 'manifest-only';
+  /** `config-no-tier` only; `undefined` for a non-literal `tokenSource` (Peter, 2026-09-26). */
+  attemptedTokenSource?: string;
+  signals: { config: boolean; tier: boolean; manifest: boolean; legacyManifest: boolean };
+}
+export interface ResolvedDataRoot {
   path: string;
-  source: 'env' | 'cwd' | 'package';
+  source: 'env' | 'cwd' | 'package' | 'package-consume';
+}
+export interface ComponentRootsResult {
+  roots: string[];
+  sources: ResolvedDataRoot['source'][];
 }
-interface McpDataRootsModule {
+export type TokenIndexResolution =
+  | { ok: true; path: string; source: ResolvedDataRoot['source']; tokenOrigin?: 'designerpunk-package-mode' | 'designerpunk-reference' }
+  | { ok: false; reason: 'empty-env-value' }
+  | { ok: false; reason: 'run-generate' }
+  | { ok: false; reason: 'partial'; partialCase?: DesignSystemRootShape['partialCase'] };
+export interface McpDataRootsModule {
   resolvePackageRoot(fromDir: string): string;
   resolvePackageOwnedRoot(opts: {
     envValue?: string;
     packageRoot: string;
     relPath: string;
   }): ResolvedDataRoot;
+  /** @deprecated Spec 123 Task 1.2 — superseded by the birth-aware resolvers below. Kept so this bootstrap block keeps compiling until Tasks 1.4–1.6 rewire it. */
   resolveConsumerOwnedRoot(opts: {
     envValue?: string;
     relPath: string;
     packageRoot?: string;
   }): ResolvedDataRoot;
+  resolveComponentRoots(opts: {
+    envValue?: string;
+    dsRoot: DesignSystemRootShape;
+    packageRoot: string;
+  }): ComponentRootsResult;
+  resolveTokenIndexRoot(opts: {
+    envValue?: string;
+    dsRoot: DesignSystemRootShape;
+    packageRoot: string;
+  }): TokenIndexResolution;
+}
+
+/**
+ * Shape-only declaration of the root-compiled `bornRepo` module (Spec 123 Task 1.4) — the same
+ * CONSUMPTION CONTRACT as `McpDataRootsModule`; `mcpDataRootsDeclaration.test.ts` guards parity.
+ */
+export interface BornRepoModule {
+  findDesignSystemRoot(startDir: string): DesignSystemRootShape;
+}
+
+/**
+ * Shape-only declaration of the root-compiled `errorCatalog` module (Spec 123 Task 1.6) —
+ * the same CONSUMPTION CONTRACT as `McpDataRootsModule`/`BornRepoModule`.
+ */
+export interface ErrorCatalogModule {
+  partialCaseMessage(
+    root: string,
+    partialCase: NonNullable<DesignSystemRootShape['partialCase']>,
+    attemptedTokenSource: string | undefined
+  ): string;
+  packageModeIndexAbsentMessage(): string;
+  bornIndexAbsentMessage(root: string): string;
+  explicitTokenIndexMissingMessage(explicitPath: string): string;
+}
+
+/**
+ * Pick the design.md catalog string for a refused token-index resolution (Spec 123
+ * Task 1.6). Extracted as a pure, exported function (rather than inlined in the
+ * `require.main` bootstrap guard below) so it is unit-testable without the
+ * dist-require machinery — see `errorCatalogWiring.test.ts`.
+ *
+ * `run-generate` picks born vs package-mode by `dsRoot.state`, because the
+ * resolver's `reason` alone doesn't carry which posture produced it.
+ */
+export function resolveTokenIndexUnavailableMessage(
+  reason: 'empty-env-value' | 'run-generate' | 'partial',
+  dsRoot: DesignSystemRootShape,
+  packageRoot: string,
+  errorCatalog: ErrorCatalogModule,
+  explicitTokenIndexDirEnv: string | undefined
+): string {
+  switch (reason) {
+    case 'empty-env-value':
+      return errorCatalog.explicitTokenIndexMissingMessage(explicitTokenIndexDirEnv ?? '');
+    case 'run-generate':
+      return dsRoot.state === 'package-mode'
+        ? errorCatalog.packageModeIndexAbsentMessage()
+        : errorCatalog.bornIndexAbsentMessage(dsRoot.root ?? packageRoot);
+    case 'partial':
+      return dsRoot.partialCase
+        ? errorCatalog.partialCaseMessage(dsRoot.root ?? packageRoot, dsRoot.partialCase, dsRoot.attemptedTokenSource)
+        : `token index unavailable: partial state with no named sub-case`;
+  }
 }
 
 // Start server — resolve data roots (Spec 121 F-C2), then boot.
@@ -540,18 +699,30 @@ if (require.main === module) {
   let dataPaths: DataPaths;
   try {
     const shared = require('../../dist/cli/shared/mcpDataRoots') as McpDataRootsModule;
+    const bornRepo = require('../../dist/cli/shared/bornRepo') as BornRepoModule;
+    const errorCatalog = require('../../dist/cli/shared/errorCatalog') as ErrorCatalogModule;
     const packageRoot = shared.resolvePackageRoot(__dirname);
 
-    // CONSUMER-OWNED roots: env → cwd (exists AND non-empty) → package fallback.
-    // The consumer's own regenerated data wins when present (Spec 118 Class C′).
-    const components = shared.resolveConsumerOwnedRoot({
-      envValue: process.env.COMPONENTS_DIR,
-      relPath: DEFAULT_COMPONENTS_DIR,
+    // Spec 123 C2/C3: birth detection from the INVOKING process's cwd (D-B3 — never
+    // __dirname/pkgRoot; the runner spawns this server with no `cwd` option, so it inherits).
+    const dsRoot = bornRepo.findDesignSystemRoot(process.cwd());
+
+    // COMPONENT ROOT SET (C3): consumer root (env, else bornRoot/src/components when born)
+    // UNION the package root — the env value names the consumer root, never the only root.
+    const componentRoots = shared.resolveComponentRoots({
+      envValue: process.env.COMPONENTS_DIR || process.env.COMPONENT_DIR,
+      dsRoot,
       packageRoot,
     });
-    const tokenIndex = shared.resolveConsumerOwnedRoot({
+
+    // C3: projectRoot = bornRoot (any state with a resolved root); unborn → the package root, labelled.
+    const projectRoot = dsRoot.root ?? packageRoot;
+
+    // TOKEN INDEX (C3): birth-aware. A structural reason is logged when no index can be served;
+    // the catalog message strings for those reasons are Task 1.6's.
+    const tokenIndex = shared.resolveTokenIndexRoot({
       envValue: process.env.TOKEN_INDEX_DIR,
-      relPath: DEFAULT_TOKEN_INDEX_DIR,
+      dsRoot,
       packageRoot,
     });
 
@@ -585,14 +756,32 @@ if (require.main === module) {
 
     // Boot log: one stderr line per data root, BEFORE the startup sentinel.
     // NEVER stdout — stdout is the JSON-RPC channel.
-    logRoot('components', components);
-    logRoot(
-      'token-index',
-      tokenIndex,
-      tokenIndex.source === 'package'
-        ? " — package token snapshot in use; if this project customizes tokens, run 'npx designerpunk generate' to build a local token-index"
-        : ''
+    console.error(`[${SERVER_NAME}] Design-system root: ${dsRoot.state}${dsRoot.partialCase ? ` (${dsRoot.partialCase})` : ''}`);
+    console.error(
+      `[${SERVER_NAME}] Project root: ${projectRoot} (source: ${dsRoot.root ? dsRoot.state : 'unborn → package'})`
     );
+    componentRoots.roots.forEach((root, i) => {
+      logRoot(`components[${i}]`, { path: root, source: componentRoots.sources[i] });
+    });
+    if (tokenIndex.ok) {
+      logRoot(
+        'token-index',
+        { path: tokenIndex.path, source: tokenIndex.source },
+        tokenIndex.tokenOrigin ? ` (tokenOrigin: ${tokenIndex.tokenOrigin})` : ''
+      );
+    } else {
+      // Spec 123 Task 1.6: the design.md catalog string for this reason — never a
+      // paraphrase. Extracted to `resolveTokenIndexUnavailableMessage` (above) so
+      // it's unit-testable outside this bootstrap guard.
+      const tokenIndexMessage = resolveTokenIndexUnavailableMessage(
+        tokenIndex.reason,
+        dsRoot,
+        packageRoot,
+        errorCatalog,
+        process.env.TOKEN_INDEX_DIR
+      );
+      console.error(`[${SERVER_NAME}] ${tokenIndexMessage}`);
+    }
     logRoot('experience-patterns', patterns);
     logRoot('layout-templates', templates);
     logRoot('family-guidance', guidance);
@@ -600,12 +789,13 @@ if (require.main === module) {
     logRoot('design-language', designLanguage);
 
     dataPaths = {
-      componentsDir: components.path,
+      componentsDir: componentRoots.roots,
+      projectRoot,
       patternsDir: patterns.path,
       templatesDir: templates.path,
       guidanceDir: guidance.path,
       registryPath: registry.path,
-      tokenIndexDir: tokenIndex.path,
+      tokenIndexDir: tokenIndex.ok ? tokenIndex.path : undefined,
       designLanguagePath: designLanguage.path,
     };
   } catch {