@3fn/core 14.0.0 → 15.0.0

package/src/cli/resolveTokens.ts

@@ -1,123 +0,0 @@
-/**
- * Token Resolver
- *
- * Resolves tokens from the configured source (local or package).
- * Verifies barrel contract before loading.
- *
- * @see Spec 103 design.md § "Token Resolver"
- */
-
-import type { PrimitiveToken } from '../types/PrimitiveToken';
-import type { SemanticToken } from '../types/SemanticToken';
-import type { ResolvedConfig } from '../config/ConfigLoader';
-import { scopedTsRequire, type TsModuleLoader } from '../config/scopedTsRequire';
-
-/** Token data resolved from the configured source. */
-export interface TokenInput {
-  primitiveTokens: PrimitiveToken[];
-  semanticTokens: SemanticToken[];
-}
-
-/**
- * Resolve tokens from the configured source.
- * Verifies barrel contract, then loads token arrays.
- *
- * @param config - Resolved pipeline configuration.
- * @param loadModule - Injectable runtime-TS resolution seam (Spec 118 Task 9.5). Defaults
- *   to {@link scopedTsRequire} (Approach A scoped `tsx/cjs/api`) — the per-site scope that
- *   makes this consumer-`.ts` load independent of the bin's global register. In-process
- *   jest callers must inject a jest-compatible loader (Approach A cannot run inside jest;
- *   see {@link scopedTsRequire}). The build script injects the AMBIENT tsx loader (a plain
- *   `require`) so generation under `tsx <script>` does not tear down its ambient hook.
- */
-export function resolveTokens(
-  config: ResolvedConfig,
-  loadModule: TsModuleLoader = scopedTsRequire,
-): TokenInput {
-  const sourcePath = config.tokenSourceRoot;
-
-  verifyBarrelContract(sourcePath, loadModule);
-
-  // Scoped runtime-TS require of the consumer's token barrel (`.ts` in the consumer repo).
-  const tokenBarrel = loadModule(sourcePath, __filename) as any;
-  const semanticBarrel = loadModule(`${sourcePath}/semantic`, __filename) as any;
-
-  return {
-    primitiveTokens: tokenBarrel.getAllPrimitiveTokens(),
-    semanticTokens: semanticBarrel.getAllSemanticTokens(),
-  };
-}
-
-/**
- * Verify the token source directory exports the required barrel functions.
- * Throws with actionable error messages on failure.
- *
- * @param sourcePath - Resolved token source root.
- * @param loadModule - Injectable runtime-TS resolution seam (see {@link resolveTokens}).
- *   Defaults to {@link scopedTsRequire}.
- */
-export function verifyBarrelContract(
-  sourcePath: string,
-  loadModule: TsModuleLoader = scopedTsRequire,
-): void {
-  let tokenBarrel: any;
-  try {
-    tokenBarrel = loadModule(sourcePath, __filename);
-  } catch (err: any) {
-    const msg = err?.message || String(err);
-    // Distinguish "file not found" from "file found but has unresolved imports"
-    if (msg.includes(`Cannot find module '${sourcePath}'`) || msg.includes(`Cannot find module "${sourcePath}"`)) {
-      throw new Error(
-        `Token source not found at: ${sourcePath}\n` +
-        `Expected a barrel file (index.ts) exporting getAllPrimitiveTokens().`
-      );
-    }
-    throw new Error(
-      `Token source at ${sourcePath} failed to load.\n\n` +
-      `  Import resolution error:\n` +
-      `    ${msg}\n\n` +
-      `  Your local token source has unresolved dependencies.\n` +
-      `  Token files should import types from the package:\n` +
-      `    import { PrimitiveToken } from '@3fn/core/types';\n\n` +
-      `  If you cannot resolve the imports, remove \`tokenSource\` from config\n` +
-      `  to use package tokens instead.`
-    );
-  }
-
-  if (typeof tokenBarrel.getAllPrimitiveTokens !== 'function') {
-    throw new Error(
-      `Token source at ${sourcePath} does not export getAllPrimitiveTokens().\n` +
-      `Expected: export function getAllPrimitiveTokens(): PrimitiveToken[]`
-    );
-  }
-
-  let semanticBarrel: any;
-  try {
-    semanticBarrel = loadModule(`${sourcePath}/semantic`, __filename);
-  } catch (err: any) {
-    const msg = err?.message || String(err);
-    if (msg.includes('Cannot find module') && msg.includes(`${sourcePath}/semantic`)) {
-      throw new Error(
-        `Semantic token source not found at: ${sourcePath}/semantic\n` +
-        `Expected a semantic/ subdirectory with barrel file exporting getAllSemanticTokens().`
-      );
-    }
-    throw new Error(
-      `Semantic token source at ${sourcePath}/semantic failed to load.\n\n` +
-      `  Import resolution error:\n` +
-      `    ${msg}\n\n` +
-      `  Your local token source has unresolved dependencies.\n` +
-      `  Token files should import types from the package:\n` +
-      `    import { SemanticToken } from '@3fn/core/types';\n\n` +
-      `  If you cannot resolve the imports, remove \`tokenSource\` from config\n` +
-      `  to use package tokens instead.`
-    );
-  }
-
-  if (typeof semanticBarrel.getAllSemanticTokens !== 'function') {
-    throw new Error(
-      `Semantic token source at ${sourcePath}/semantic does not export getAllSemanticTokens().\n` +
-      `Expected: export function getAllSemanticTokens(): SemanticToken[]`
-    );
-  }
-}

package/src/cli/shared/mcpDataRoots.ts

@@ -1,122 +0,0 @@
-/**
- * Shared MCP data-root resolution (Spec 121 F-C2 patch).
- *
- * Single source of truth for how the three MCP servers (docs, application, product)
- * resolve their data roots. Before this module existed, all three servers defaulted
- * their data roots cwd-relative, so a hand-wired consumer (no env vars) booting the
- * bundled servers from `node_modules/@3fn/core` got an EMPTY index (finding F-C2,
- * `.kiro/specs/121-claude-code-portability/consumer-dry-run-findings.md` § A).
- *
- * Resolution order is per-root by DATA OWNERSHIP (Ada's ruling, grounded in the
- * Spec 118 Module-Resolution Contract Class C′):
- *
- * - PACKAGE-OWNED roots (docs `governance/`; application's design-philosophy.yaml,
- *   family-guidance, experience-patterns, layout-templates, family-registry):
- *   env var → package-relative. NO cwd preference — a consumer's coincidental
- *   `governance/` dir is not the DesignerPunk corpus; the env var is the sanctioned
- *   override. (Dev repo unaffected: cwd == package root there.)
- *
- * - CONSUMER-OWNED roots (`token-index/`, `src/components/core`, `product/`):
- *   env var → cwd-relative if it exists AND is non-empty → package-relative
- *   fallback. Class C′ mandates the consumer's own regenerated data wins when
- *   present. The product server's `product/` root gets NO package fallback
- *   (consumer-owned by definition; an empty index there is expected/correct) —
- *   callers omit `packageRoot` for it.
- *
- * All resolved paths are ABSOLUTE — the servers wire them into FileWatcher and
- * StalenessGate, whose `/node_modules/` immutability check only works on absolute
- * paths (mcp-server/src/staleness/StalenessGate.ts).
- *
- * CONSUMPTION CONTRACT (why servers require the DIST artifact of this file):
- * The MCP server sources live in sub-packages (`mcp-server/src`,
- * `application-mcp-server/src`) whose tsc builds have `rootDir: "./src"` — a static
- * TS import of this file would cross that boundary and fail/nest the sub-package
- * dist (Spec 118 Class C risk). Instead the servers load the ROOT-COMPILED artifact
- * via `require('../../dist/cli/shared/mcpDataRoots')` inside their entry-point-only
- * code paths:
- *   - esbuild bundles (`dist/mcp/*.js`): the require is statically resolved and
- *     INLINED at build time (`build:mcp` compiles this file to dist first).
- *   - sub-package tsc artifacts (`mcp-server/dist/index.js`,
- *     `application-mcp-server/dist/index.js`): the require resolves at runtime to
- *     `<repo>/dist/cli/shared/mcpDataRoots.js` (root build output).
- * NEVER copy this logic locally — duplicated-resolution-logic drift is this
- * project's named recurring failure mode.
- */
-import * as path from 'path';
-import * as fs from 'fs';
-
-// Re-exported so MCP server entry points need exactly ONE shared require.
-export { resolvePackageRoot } from './resolvePackageRoot';
-
-/** Which resolution source won for a data root. */
-export type DataRootSource = 'env' | 'cwd' | 'package';
-
-/** A resolved data root: absolute path + which source won. */
-export interface ResolvedDataRoot {
-  /** Absolute path to the data root. */
-  path: string;
-  /** Which source won: 'env' | 'cwd' | 'package'. */
-  source: DataRootSource;
-}
-
-/**
- * Resolve a PACKAGE-OWNED data root: env var → package-relative.
- * No cwd preference (see header).
- */
-export function resolvePackageOwnedRoot(opts: {
-  /** The env-var value, if set (e.g. process.env.MCP_STEERING_DIR). */
-  envValue?: string;
-  /** Absolute package root (from resolvePackageRoot(__dirname)). */
-  packageRoot: string;
-  /** Path of this root relative to the package root (e.g. 'governance/'). */
-  relPath: string;
-}): ResolvedDataRoot {
-  if (opts.envValue) {
-    return { path: path.resolve(opts.envValue), source: 'env' };
-  }
-  return { path: path.resolve(opts.packageRoot, opts.relPath), source: 'package' };
-}
-
-/**
- * Resolve a CONSUMER-OWNED data root: env var → cwd-relative (if exists AND
- * non-empty) → package-relative fallback (only when `packageRoot` is provided).
- * When `packageRoot` is omitted (product server's `product/` root), the
- * cwd-relative absolute path is returned even if absent — the server's existing
- * "starting with empty data" behavior is the correct outcome there.
- */
-export function resolveConsumerOwnedRoot(opts: {
-  /** The env-var value, if set (e.g. process.env.TOKEN_INDEX_DIR). */
-  envValue?: string;
-  /** Path of this root relative to cwd/package root (e.g. 'token-index'). */
-  relPath: string;
-  /** Absolute package root; OMIT to disable the package fallback. */
-  packageRoot?: string;
-}): ResolvedDataRoot {
-  if (opts.envValue) {
-    return { path: path.resolve(opts.envValue), source: 'env' };
-  }
-  const cwdPath = path.resolve(process.cwd(), opts.relPath);
-  if (existsNonEmpty(cwdPath)) {
-    return { path: cwdPath, source: 'cwd' };
-  }
-  if (opts.packageRoot) {
-    return { path: path.resolve(opts.packageRoot, opts.relPath), source: 'package' };
-  }
-  return { path: cwdPath, source: 'cwd' };
-}
-
-/**
- * True when the path exists and is non-empty (non-empty directory, or a file
- * with content). An empty consumer dir must NOT shadow the package fallback.
- */
-function existsNonEmpty(p: string): boolean {
-  try {
-    const stat = fs.statSync(p);
-    if (stat.isDirectory()) {
-      return fs.readdirSync(p).length > 0;
-    }
-    return stat.size > 0;
-  } catch {
-    return false;
-  }
-}

package/src/cli/shared/resolvePackageRoot.ts

@@ -1,58 +0,0 @@
-/**
- * Shared package-root resolution (Spec 118 Task 9.5.2, Class C).
- *
- * Single source of truth for "where is the DesignerPunk package root" — the robust
- * self-checking pattern that previously existed as two copy-paste copies in
- * `designerpunk.ts` (B3, `:80`) and `init.ts` (B4, `:219`). Both resolved two levels
- * up from the CLI file's `__dirname` (`src/cli/` → package root, or `dist/cli/` →
- * package root under a packed install), self-checked for a `package.json`, and fell
- * back to `process.cwd()`. This util unifies them so there is ONE mechanism, no
- * copy-paste, and the package root is relocation-safe — a prerequisite for the target
- * model's compile-to-`dist` step (`findings/runtime-ts-resolution-target-model.md`
- * § Class C / step 4).
- *
- * Resolution behavior is intentionally IDENTICAL to the two copies it replaced:
- * resolve `<fromDir>/../..`, return it iff it contains `package.json`, else fall
- * back to cwd — now with a stderr warning when the fallback triggers (silent
- * fallback is the F-C2-class failure mode; see `mcpDataRoots.ts`). Callers MUST
- * pass their own `__dirname` so the two-levels-up offset is computed from the
- * calling file's location.
- *
- * LEVELS-UP ASSUMPTION — every caller's module sits exactly TWO levels below the
- * package root. Current callers (Spec 121 F-C2 patch added the MCP entry points):
- *   - `src/cli/designerpunk.ts`, `src/cli/init.ts`      → `src/cli/`  (dev/ts-node)
- *   - `dist/cli/designerpunk.js`, `dist/cli/init.js`    → `dist/cli/` (packed install)
- *   - `src/config/ConfigLoader.ts` / `dist/config/`     → two levels down likewise
- *   - esbuild MCP bundles `dist/mcp/*.js` (docs/application/product servers pass
- *     the bundle's `__dirname`)                          → `dist/mcp/`
- *   - sub-package tsc artifacts `mcp-server/dist/index.js`,
- *     `application-mcp-server/dist/index.js` (each sub-package dir sits at the
- *     repo root, so `<sub>/dist` is also two levels down); their ts-node/src forms
- *     (`mcp-server/src/index.ts` etc.) are two levels down as well.
- * If a future caller does NOT sit two levels below the package root, do not fork
- * this logic — generalize THIS function (e.g. to an upward walk) instead.
- *
- * This util lives at `src/cli/shared/`, so it cannot use its own `__dirname`.
- *
- * @param fromDir - The calling module's `__dirname` (REQUIRED — see note above).
- * @returns Absolute path to the package root, or `process.cwd()` if the self-check fails.
- */
-import * as path from 'path';
-import * as fs from 'fs';
-
-export function resolvePackageRoot(fromDir: string): string {
-  // The calling entry files live two levels below the package root (see the
-  // LEVELS-UP ASSUMPTION in the header).
-  const fromCli = path.resolve(fromDir, '../..');
-  if (fs.existsSync(path.join(fromCli, 'package.json'))) {
-    return fromCli;
-  }
-  // Self-check failed — warn on stderr (NEVER stdout: for MCP servers stdout is
-  // the JSON-RPC channel). A silent cwd fallback here is exactly the class of
-  // failure the F-C2 patch exists to kill.
-  console.error(
-    `[resolvePackageRoot] WARNING: no package.json two levels above ${fromDir} — ` +
-      `falling back to cwd (${process.cwd()}). Package-relative data may not resolve.`,
-  );
-  return process.cwd();
-}

package/src/cli/shared/transforms.ts

@@ -1,18 +0,0 @@
-/**
- * Shared content transforms used by both `init` and `sync` commands.
- */
-
-/**
- * Rewrite build system imports to use @3fn/core/build package subpath.
- * Converts: import { defineComponentTokens } from '../../build/tokens'
- * To:       import { defineComponentTokens } from '@3fn/core/build'
- *
- * Handles any depth of relative path (../build/tokens, ../../build/tokens, etc.)
- * and specific file imports (../../build/tokens/defineComponentTokens).
- */
-export function rewriteBuildImports(content: string): string {
-  return content.replace(
-    /from\s+['"]\.\.\/(?:\.\.\/)*build\/tokens(?:\/[^'"]*)?['"]/g,
-    `from '@3fn/core/build'`,
-  );
-}

package/src/cli/staleness.ts

@@ -1,81 +0,0 @@
-/**
- * Product Token Staleness Detection
- *
- * Compares modification times of product token YAML source files against
- * generated output files to determine if regeneration is needed.
- *
- * @see Spec 114 design.md § "isProductTokenStale"
- */
-
-import * as fs from 'fs';
-import * as path from 'path';
-import type { ResolvedConfig } from '../config/ConfigLoader';
-
-const PRODUCT_OUTPUT_FILES = [
-  'ProductTokens.web.css',
-  'ProductTokens.ios.swift',
-  'ProductTokens.android.kt',
-];
-
-/**
- * Get all product token output file paths for the configured platforms.
- */
-export function getProductTokenOutputPaths(config: ResolvedConfig): string[] {
-  const outputDir = path.join(config.outputDir, 'product');
-  return PRODUCT_OUTPUT_FILES.map(f => path.join(outputDir, f));
-}
-
-/**
- * Check whether product token output is stale relative to YAML source.
- *
- * Returns true if:
- * - --force flag is present
- * - Any output file is missing
- * - Any source YAML file is newer than the oldest output file
- */
-export function isProductTokenStale(config: ResolvedConfig, force = false): boolean {
-  if (force) return true;
-
-  if (!config.productTokens || !fs.existsSync(config.productTokens)) {
-    return true;
-  }
-
-  const outputPaths = getProductTokenOutputPaths(config);
-
-  // If any output file is missing, always regenerate
-  let oldestOutputMtime = Infinity;
-  for (const outputPath of outputPaths) {
-    if (!fs.existsSync(outputPath)) return true;
-    const mtime = fs.statSync(outputPath).mtimeMs;
-    if (mtime < oldestOutputMtime) oldestOutputMtime = mtime;
-  }
-
-  // Find all YAML source files
-  const sourceFiles = findYamlFiles(config.productTokens);
-  if (sourceFiles.length === 0) return true;
-
-  // If any source is newer than the oldest output, it's stale
-  for (const sourceFile of sourceFiles) {
-    const mtime = fs.statSync(sourceFile).mtimeMs;
-    if (mtime > oldestOutputMtime) return true;
-  }
-
-  return false;
-}
-
-/** Recursively find all .yaml files in a directory. */
-function findYamlFiles(dir: string): string[] {
-  const results: string[] = [];
-  if (!fs.existsSync(dir)) return results;
-
-  const entries = fs.readdirSync(dir, { withFileTypes: true });
-  for (const entry of entries) {
-    const fullPath = path.join(dir, entry.name);
-    if (entry.isDirectory()) {
-      results.push(...findYamlFiles(fullPath));
-    } else if (entry.name.endsWith('.yaml') || entry.name.endsWith('.yml')) {
-      results.push(fullPath);
-    }
-  }
-  return results;
-}

package/src/cli/sync/Applier.ts

@@ -1,128 +0,0 @@
-/**
- * Apply files from package to project, with tier-appropriate behavior.
- *
- * @see Spec 111 — Requirement 4, Requirement 7
- */
-
-import * as fs from 'fs';
-import * as path from 'path';
-import type { ClassifiedFile } from './Classifier';
-import type { SyncManifest } from './Manifest';
-import { rewriteBuildImports } from '../shared/transforms';
-
-export interface ApplyResult {
-  applied: string[];
-  skipped: string[];
-  errors: string[];
-}
-
-/**
- * Apply a single file from package to project.
- * Applies rewriteBuildImports transform for source-tier .ts files.
- */
-export function applyFile(
-  file: ClassifiedFile,
-  packageRoot: string,
-  projectRoot: string,
-  manifest: SyncManifest,
-  options?: { force?: boolean },
-): boolean {
-  const srcPath = path.join(packageRoot, file.relativePath);
-  const destPath = path.join(projectRoot, file.relativePath);
-
-  try {
-    fs.mkdirSync(path.dirname(destPath), { recursive: true });
-
-    const isSourceTs = file.tier === 'source' && file.relativePath.endsWith('.ts');
-
-    if (isSourceTs) {
-      const content = fs.readFileSync(srcPath, 'utf-8');
-      fs.writeFileSync(destPath, rewriteBuildImports(content), 'utf-8');
-    } else {
-      fs.copyFileSync(srcPath, destPath);
-    }
-
-    // Update manifest
-    manifest.files[file.relativePath] = {
-      hash: file.packageHash,
-      managed: file.tier === 'governance',
-    };
-
-    if (options?.force && file.classification === 'conflict') {
-      console.log(`  ⚠️ overwritten (was locally modified): ${file.relativePath}`);
-    }
-
-    return true;
-  } catch (err) {
-    console.error(`  ❌ Failed to apply ${file.relativePath}: ${(err as Error).message}`);
-    return false;
-  }
-}
-
-/**
- * Apply governance-tier files (auto-apply without prompting).
- */
-export function applyGovernance(
-  files: ClassifiedFile[],
-  packageRoot: string,
-  projectRoot: string,
-  manifest: SyncManifest,
-): ApplyResult {
-  const governance = files.filter(f => f.tier === 'governance');
-  const result: ApplyResult = { applied: [], skipped: [], errors: [] };
-
-  for (const file of governance) {
-    if (applyFile(file, packageRoot, projectRoot, manifest)) {
-      result.applied.push(file.relativePath);
-    } else {
-      result.errors.push(file.relativePath);
-    }
-  }
-
-  return result;
-}
-
-/**
- * Apply source-tier files (after confirmation).
- */
-export function applySource(
-  files: ClassifiedFile[],
-  packageRoot: string,
-  projectRoot: string,
-  manifest: SyncManifest,
-): ApplyResult {
-  const source = files.filter(f => f.tier === 'source');
-  const result: ApplyResult = { applied: [], skipped: [], errors: [] };
-
-  for (const file of source) {
-    if (applyFile(file, packageRoot, projectRoot, manifest)) {
-      result.applied.push(file.relativePath);
-    } else {
-      result.errors.push(file.relativePath);
-    }
-  }
-
-  return result;
-}
-
-/**
- * Apply force mode — all files without prompting.
- */
-export function applyForce(
-  files: ClassifiedFile[],
-  packageRoot: string,
-  projectRoot: string,
-  manifest: SyncManifest,
-): ApplyResult {
-  const result: ApplyResult = { applied: [], skipped: [], errors: [] };
-
-  for (const file of files) {
-    if (applyFile(file, packageRoot, projectRoot, manifest, { force: true })) {
-      result.applied.push(file.relativePath);
-    } else {
-      result.errors.push(file.relativePath);
-    }
-  }
-
-  return result;
-}

package/src/cli/sync/Classifier.ts

@@ -1,130 +0,0 @@
-/**
- * Classify files by comparing package, project, and manifest state.
- *
- * @see Spec 111 — Requirement 2
- */
-
-import type { ScannedFile } from './FileScanner';
-import type { SyncManifest } from './Manifest';
-import type { IgnoreFilter } from './IgnoreFilter';
-
-export type FileClassification = 'new' | 'updated-safe' | 'conflict' | 'unchanged' | 'removed';
-
-export interface ClassifiedFile {
-  relativePath: string;
-  classification: FileClassification;
-  tier: 'governance' | 'source';
-  packageHash: string;
-  projectHash?: string;
-  manifestHash?: string;
-  reason?: string;
-}
-
-export interface ClassificationResult {
-  new: ClassifiedFile[];
-  updatedSafe: ClassifiedFile[];
-  conflicts: ClassifiedFile[];
-  unchanged: ClassifiedFile[];
-  removed: ClassifiedFile[];
-}
-
-export function classifyFiles(
-  packageFiles: ScannedFile[],
-  projectFiles: ScannedFile[],
-  manifest: SyncManifest | null,
-  ignore: IgnoreFilter,
-): ClassificationResult {
-  const result: ClassificationResult = {
-    new: [],
-    updatedSafe: [],
-    conflicts: [],
-    unchanged: [],
-    removed: [],
-  };
-
-  // Index project files by relative path for O(1) lookup
-  const projectMap = new Map<string, ScannedFile>();
-  for (const f of projectFiles) {
-    projectMap.set(f.relativePath, f);
-  }
-
-  const manifestFiles = manifest?.files ?? {};
-
-  // Iterate package files only (package-direction guarantee)
-  for (const pkgFile of packageFiles) {
-    if (ignore.isIgnored(pkgFile.relativePath)) continue;
-
-    const projFile = projectMap.get(pkgFile.relativePath);
-    const manifestEntry = manifestFiles[pkgFile.relativePath];
-
-    if (!projFile) {
-      // R2 AC1: In package but not in project → New
-      result.new.push({
-        relativePath: pkgFile.relativePath,
-        classification: 'new',
-        tier: pkgFile.tier,
-        packageHash: pkgFile.hash,
-      });
-    } else if (pkgFile.hash === projFile.hash) {
-      // R2 AC4: Package hash equals project hash → Unchanged
-      result.unchanged.push({
-        relativePath: pkgFile.relativePath,
-        classification: 'unchanged',
-        tier: pkgFile.tier,
-        packageHash: pkgFile.hash,
-        projectHash: projFile.hash,
-        manifestHash: manifestEntry?.hash,
-      });
-    } else if (!manifestEntry) {
-      // R2 AC5: No manifest entry + hashes differ → Conflict (first encounter)
-      result.conflicts.push({
-        relativePath: pkgFile.relativePath,
-        classification: 'conflict',
-        tier: pkgFile.tier,
-        packageHash: pkgFile.hash,
-        projectHash: projFile.hash,
-        reason: 'no sync history (first encounter)',
-      });
-    } else if (manifestEntry.hash === projFile.hash) {
-      // R2 AC2: Manifest matches project (consumer hasn't edited) + package differs → Updated-safe
-      result.updatedSafe.push({
-        relativePath: pkgFile.relativePath,
-        classification: 'updated-safe',
-        tier: pkgFile.tier,
-        packageHash: pkgFile.hash,
-        projectHash: projFile.hash,
-        manifestHash: manifestEntry.hash,
-        reason: 'unchanged by you — package updated',
-      });
-    } else {
-      // R2 AC3: Manifest differs from project (consumer edited) + package differs → Conflict
-      result.conflicts.push({
-        relativePath: pkgFile.relativePath,
-        classification: 'conflict',
-        tier: pkgFile.tier,
-        packageHash: pkgFile.hash,
-        projectHash: projFile.hash,
-        manifestHash: manifestEntry.hash,
-        reason: 'locally modified',
-      });
-    }
-  }
-
-  // R2 AC6: Files in manifest but not in package → Removed
-  for (const manifestPath of Object.keys(manifestFiles)) {
-    if (ignore.isIgnored(manifestPath)) continue;
-    const inPackage = packageFiles.some(f => f.relativePath === manifestPath);
-    if (!inPackage) {
-      result.removed.push({
-        relativePath: manifestPath,
-        classification: 'removed',
-        tier: manifestFiles[manifestPath].managed ? 'governance' : 'source',
-        packageHash: '',
-        manifestHash: manifestFiles[manifestPath].hash,
-        reason: 'removed from package',
-      });
-    }
-  }
-
-  return result;
-}