elanous 0.2.0 → 0.2.5

package/src/design/design-gate.ts

@@ -0,0 +1,241 @@
+// 프로젝트 단위 디자인 관문 — 고른 방향의 토큰 대비 HTML 준수를 한 판정으로 낸다.
+// 그래프 노드는 인자 없는 한 줄을 부르므로, 이 모듈은 LLM·네트워크를 부르지 않고
+// 대상 프로젝트의 파일도 쓰지 않는다.
+
+import { execFileSync } from 'node:child_process';
+import { existsSync, readdirSync, readFileSync, statSync } from 'node:fs';
+import { join, relative, sep } from 'node:path';
+
+import { debug } from '../debug/log.js';
+import { listAllDesignDirections, parseDeclaredDirection } from './design-directions.js';
+import { runLintDesign, type TokensSource } from './lint-artifact-run.js';
+
+export type DesignGateVerdict = 'pass' | 'fail' | 'not-applicable';
+
+export type DesignGateReason = 'no-design-document' | 'no-direction' | 'no-html';
+
+export interface DesignGateFinding {
+  readonly rule: string;
+  readonly severity: 'p0' | 'advisory';
+  readonly line: number | null;
+}
+
+export interface DesignGateFile {
+  readonly path: string;
+  readonly p0: number;
+  readonly advisory: number;
+  readonly skipped: readonly string[];
+  readonly findings: readonly DesignGateFinding[];
+}
+
+export interface DesignGateResult {
+  readonly verdict: DesignGateVerdict;
+  readonly reason?: DesignGateReason;
+  readonly direction: string | null;
+  readonly tokensSource: TokensSource | null;
+  readonly p0Total: number;
+  readonly advisoryTotal: number;
+  readonly files: readonly DesignGateFile[];
+  readonly truncated: boolean;
+  readonly omitted: number;
+  readonly checkedAt: string;
+}
+
+export interface DesignGateInput {
+  readonly projectDir: string;
+  readonly base?: string;
+  readonly maxFiles?: number;
+}
+
+export interface DesignGateDeps {
+  readonly readFile?: (path: string) => string;
+  readonly exists?: (path: string) => boolean;
+  readonly listHtml?: (projectDir: string) => readonly string[];
+  readonly gitDiffNames?: (projectDir: string, base: string) => readonly string[];
+  readonly gitUntracked?: (projectDir: string) => readonly string[];
+  readonly now?: () => string;
+  readonly lint?: typeof runLintDesign;
+  readonly directions?: () => ReturnType<typeof listAllDesignDirections>;
+}
+
+const DEFAULT_MAX_FILES = 50;
+const EXCLUDED_PREFIXES = ['node_modules/', '.git/', 'design/previews/', 'design/system/'];
+
+function posixRelative(projectDir: string, filePath: string): string {
+  return relative(projectDir, filePath).split(sep).join('/');
+}
+
+function isExcludedHtml(rel: string): boolean {
+  const normalized = rel.replace(/\\/g, '/').replace(/^\.\//, '');
+  if (!normalized.endsWith('.html')) return true;
+  return EXCLUDED_PREFIXES.some((prefix) => normalized === prefix.slice(0, -1) || normalized.startsWith(prefix));
+}
+
+function walkHtml(projectDir: string, dir: string, out: string[]): void {
+  let names: string[];
+  try {
+    names = readdirSync(dir);
+  } catch {
+    return;
+  }
+  for (const name of names) {
+    const full = join(dir, name);
+    const rel = posixRelative(projectDir, full);
+    let isDirectory = false;
+    try {
+      isDirectory = statSync(full).isDirectory();
+    } catch {
+      continue;
+    }
+    if (isDirectory) {
+      if (EXCLUDED_PREFIXES.some((prefix) => rel === prefix.slice(0, -1) || rel.startsWith(prefix))) continue;
+      if (name === 'node_modules' || name === '.git') continue;
+      walkHtml(projectDir, full, out);
+      continue;
+    }
+    if (!isExcludedHtml(rel)) out.push(full);
+  }
+}
+
+function defaultListHtml(projectDir: string): string[] {
+  const out: string[] = [];
+  walkHtml(projectDir, projectDir, out);
+  return out.sort();
+}
+
+function gitLines(projectDir: string, args: readonly string[]): string[] {
+  const text = execFileSync('git', ['-C', projectDir, ...args], { encoding: 'utf8' });
+  return text.split(/\r?\n/).map((line) => line.trim()).filter((line) => line.length > 0);
+}
+
+function resolveChangedHtml(
+  projectDir: string,
+  base: string,
+  deps: Required<Pick<DesignGateDeps, 'gitDiffNames' | 'gitUntracked' | 'exists'>>,
+): string[] {
+  const names = [...deps.gitDiffNames(projectDir, base), ...deps.gitUntracked(projectDir)];
+  const seen = new Set<string>();
+  const files: string[] = [];
+  for (const name of names) {
+    const rel = name.replace(/\\/g, '/').replace(/^\.\//, '');
+    if (isExcludedHtml(rel) || seen.has(rel)) continue;
+    const full = join(projectDir, rel);
+    if (!deps.exists(full)) continue;
+    try {
+      if (!statSync(full).isFile()) continue;
+    } catch {
+      continue;
+    }
+    seen.add(rel);
+    files.push(full);
+  }
+  return files.sort();
+}
+
+function emptyResult(
+  verdict: DesignGateVerdict,
+  reason: DesignGateReason | undefined,
+  direction: string | null,
+  checkedAt: string,
+): DesignGateResult {
+  return {
+    verdict,
+    ...(reason ? { reason } : {}),
+    direction,
+    tokensSource: null,
+    p0Total: 0,
+    advisoryTotal: 0,
+    files: [],
+    truncated: false,
+    omitted: 0,
+    checkedAt,
+  };
+}
+
+export function runDesignGate(input: DesignGateInput, deps: DesignGateDeps = {}): DesignGateResult {
+  const readFile = deps.readFile ?? ((path: string) => readFileSync(path, 'utf8'));
+  const exists = deps.exists ?? existsSync;
+  const listHtml = deps.listHtml ?? defaultListHtml;
+  const gitDiffNames = deps.gitDiffNames ?? ((projectDir: string, base: string) => gitLines(projectDir, ['diff', '--name-only', `${base}...HEAD`]));
+  const gitUntracked = deps.gitUntracked ?? ((projectDir: string) => gitLines(projectDir, ['ls-files', '--others', '--exclude-standard']));
+  const now = deps.now ?? (() => new Date().toISOString());
+  const lint = deps.lint ?? runLintDesign;
+  const directions = deps.directions ?? (() => listAllDesignDirections());
+  const checkedAt = now();
+  const maxFiles = input.maxFiles ?? DEFAULT_MAX_FILES;
+  const designPath = join(input.projectDir, 'DESIGN.md');
+
+  let result: DesignGateResult;
+  if (!exists(designPath)) {
+    result = emptyResult('not-applicable', 'no-design-document', null, checkedAt);
+  } else {
+    const document = readFile(designPath);
+    const parsed = parseDeclaredDirection(document, directions());
+    if (parsed.declared === null) {
+      result = emptyResult('not-applicable', 'no-direction', null, checkedAt);
+    } else {
+      const htmlFiles = input.base
+        ? resolveChangedHtml(input.projectDir, input.base, { gitDiffNames, gitUntracked, exists })
+        : [...listHtml(input.projectDir)].filter((file) => !isExcludedHtml(posixRelative(input.projectDir, file))).sort();
+      if (htmlFiles.length === 0) {
+        result = emptyResult('not-applicable', 'no-html', parsed.declared, checkedAt);
+      } else {
+        const limited = htmlFiles.slice(0, Math.max(0, maxFiles));
+        const omitted = htmlFiles.length - limited.length;
+        let tokensSource: TokensSource | null = null;
+        const files: DesignGateFile[] = limited.map((htmlPath, index) => {
+          const run = lint({ htmlPath, designPath });
+          if (index === 0) tokensSource = run.tokensSource;
+          return {
+            path: posixRelative(input.projectDir, htmlPath) || htmlPath,
+            p0: run.p0Count,
+            advisory: run.advisoryCount,
+            skipped: [...run.skipped],
+            findings: run.findings.map((finding) => ({
+              rule: finding.rule,
+              severity: finding.severity,
+              line: finding.line,
+            })),
+          };
+        });
+        const p0Total = files.reduce((sum, file) => sum + file.p0, 0);
+        const advisoryTotal = files.reduce((sum, file) => sum + file.advisory, 0);
+        result = {
+          verdict: p0Total >= 1 ? 'fail' : 'pass',
+          direction: parsed.declared,
+          tokensSource,
+          p0Total,
+          advisoryTotal,
+          files,
+          truncated: omitted > 0,
+          omitted,
+          checkedAt,
+        };
+      }
+    }
+  }
+
+  debug.log('design.gate', 'verdict', {
+    projectDir: input.projectDir,
+    direction: result.direction,
+    verdict: result.verdict,
+    p0Total: result.p0Total,
+    fileCount: result.files.length,
+  });
+  return result;
+}
+
+export function formatDesignGate(result: DesignGateResult): string[] {
+  const headline = result.verdict === 'not-applicable'
+    ? `design-gate ${result.verdict} (${result.reason ?? 'unknown'})`
+    : `design-gate ${result.verdict} direction=${result.direction ?? '(none)'} p0=${result.p0Total} advisory=${result.advisoryTotal}`;
+  const lines = [headline];
+  for (const file of result.files) {
+    const firstP0 = file.findings.find((finding) => finding.severity === 'p0');
+    lines.push(`${file.path} p0=${file.p0}${firstP0 ? ` ${firstP0.rule}` : ''}`);
+  }
+  const unchecked = result.files.reduce((sum, file) => sum + file.skipped.length, 0);
+  lines.push(`unchecked ${unchecked}`);
+  if (result.truncated) lines.push(`truncated omitted=${result.omitted}`);
+  return lines;
+}

package/src/design/design-library.ts

@@ -0,0 +1,57 @@
+// 사용자 디자인 시스템 라이브러리. 번들 `docs/design/systems/` 는 읽기만 한다.
+
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { isAbsolute, join } from 'node:path';
+import { getElanousConfigDir } from '../elanous-config-dir.js';
+import { elanousStateRoot } from '../autopilot/state-paths.js';
+import { defaultDesignSystemsDir, listDesignSystems } from './design-systems.js';
+import { THEME_REGISTRY } from '../themes/index.js';
+import type { PromotedSystem } from './system-from-extract.js';
+
+const ID_PATTERN = /^[a-z0-9-]+$/;
+
+export function libraryDir(): string {
+  const configured = configuredLibraryDir();
+  if (configured) return configured;
+  // ⛔ 우주(운영/격리)를 따르는 상태 루트 아래 — `~/.elanous` 를 박으면 격리 시험이 운영 라이브러리에 쓴다.
+  return join(elanousStateRoot(), 'design', 'systems');
+}
+
+function configuredLibraryDir(): string | null {
+  try {
+    const raw = JSON.parse(readFileSync(join(getElanousConfigDir(), 'config.json'), 'utf8')) as { design?: { libraryDir?: unknown } };
+    const value = raw.design?.libraryDir;
+    if (typeof value !== 'string' || !value.trim()) return null;
+    const trimmed = value.trim();
+    return isAbsolute(trimmed) ? trimmed : join(getElanousConfigDir(), trimmed);
+  } catch {
+    return null;
+  }
+}
+
+export function reservedDesignIds(systemsDir: string = defaultDesignSystemsDir()): Set<string> {
+  const ids = new Set<string>(THEME_REGISTRY.map((theme) => theme.name));
+  for (const system of listDesignSystems(systemsDir)) ids.add(system.id);
+  return ids;
+}
+
+export function saveCustomSystem(
+  dir: string,
+  system: PromotedSystem,
+  options: { systemsDir?: string } = {},
+): { dir: string } {
+  const id = system.manifest.id;
+  if (!ID_PATTERN.test(id)) throw new Error(`design system id 거부: ${id}`);
+  if (reservedDesignIds(options.systemsDir).has(id)) throw new Error(`design system id 가 번들 또는 테마와 겹친다: ${id}`);
+  const rootSource = join(dir, 'SOURCE.json');
+  if (!existsSync(rootSource)) {
+    mkdirSync(dir, { recursive: true });
+    writeFileSync(rootSource, `${JSON.stringify({ commit: 'custom' }, null, 2)}\n`);
+  }
+  const folder = join(dir, id);
+  mkdirSync(folder, { recursive: true });
+  writeFileSync(join(folder, 'manifest.json'), `${JSON.stringify(system.manifest, null, 2)}\n`);
+  writeFileSync(join(folder, 'DESIGN.md'), system.designMd);
+  writeFileSync(join(folder, 'tokens.css'), system.tokensCss);
+  return { dir: folder };
+}

package/src/design/design-previews.ts

@@ -0,0 +1,138 @@
+import { mkdirSync, writeFileSync } from 'node:fs';
+import { basename } from 'node:path';
+
+import {
+  createProject,
+  getRun,
+  listFiles,
+  openDesignConfig,
+  readFile,
+  startRun,
+  type OpenDesignClientDeps,
+  type OpenDesignConnection,
+} from './open-design-client.js';
+
+export const DESIGN_PREVIEW_POLL_MS = 10_000;
+export const DESIGN_PREVIEW_TIMEOUT_MS = 15 * 60_000;
+
+const TERMINAL = new Set(['succeeded', 'failed', 'cancelled']);
+
+export interface DesignPreviewInput {
+  repoRoot: string;
+  brief: string;
+  systems: string[];
+  agentId?: string;
+  pollMs?: number;
+  timeoutMs?: number;
+}
+
+export interface DesignPreviewResult {
+  system: string;
+  ok: boolean;
+  path?: string;
+  runId?: string;
+  status: string;
+  reason?: string;
+}
+
+export interface DesignPreviewDeps extends OpenDesignClientDeps {
+  connection?: OpenDesignConnection | null;
+  now?: () => number;
+  sleep?: (ms: number) => Promise<void>;
+  mkdir?: (path: string) => void;
+  writeFile?: (path: string, contents: string) => void;
+  clock?: () => string;
+}
+
+function safeIdPart(value: string): string {
+  const cleaned = value.toLowerCase().replace(/[^a-z0-9-]+/g, '-').replace(/^-+|-+$/g, '');
+  return cleaned || 'x';
+}
+
+export function designPreviewProjectId(repoRoot: string, system: string, stamp: string): string {
+  return `elanous-${safeIdPart(basename(repoRoot))}-${safeIdPart(system)}-${safeIdPart(stamp)}`;
+}
+
+function firstHtml(names: readonly string[]): string | undefined {
+  return names.find((name) => name.toLowerCase().endsWith('.html'));
+}
+
+async function previewOne(
+  input: DesignPreviewInput,
+  system: string,
+  connection: OpenDesignConnection,
+  deps: DesignPreviewDeps,
+): Promise<DesignPreviewResult> {
+  const stamp = (deps.clock ?? (() => new Date().toISOString().replace(/[-:.TZ]/g, '').slice(0, 14)))();
+  const id = designPreviewProjectId(input.repoRoot, system, stamp);
+  const created = await createProject({ id, name: `${basename(input.repoRoot)} ${system}`, designSystemId: system }, connection, deps);
+  if (!created.ok) return { system, ok: false, status: 'error', reason: created.reason };
+
+  const started = await startRun({
+    projectId: created.project.id,
+    message: input.brief,
+    agentId: input.agentId ?? 'codex',
+  }, connection, deps);
+  if (!started.ok) return { system, ok: false, status: 'error', reason: started.reason };
+
+  const pollMs = input.pollMs ?? DESIGN_PREVIEW_POLL_MS;
+  const timeoutMs = input.timeoutMs ?? DESIGN_PREVIEW_TIMEOUT_MS;
+  const startedAt = (deps.now ?? Date.now)();
+  const sleep = deps.sleep ?? ((ms: number) => new Promise((resolve) => setTimeout(resolve, ms)));
+  let status = 'queued';
+  let runError: string | null = null;
+  for (;;) {
+    const run = await getRun(started.runId, connection, deps);
+    if (!run.ok) return { system, ok: false, runId: started.runId, status: 'error', reason: run.reason };
+    status = run.run.status ?? status;
+    runError = typeof run.run.error === 'string' && run.run.error.trim() ? run.run.error.trim().slice(0, 200) : null;
+    if (TERMINAL.has(status)) break;
+    if ((deps.now ?? Date.now)() - startedAt >= timeoutMs) {
+      return { system, ok: false, runId: started.runId, status: 'timeout', reason: 'timeout' };
+    }
+    await sleep(pollMs);
+  }
+  if (status !== 'succeeded') {
+    // OpenDesign says WHY (e.g. the engine could not authenticate) — carry that sentence, not just the status.
+    return { system, ok: false, runId: started.runId, status, reason: runError ? `${status}: ${runError}` : status };
+  }
+
+  const listed = await listFiles(created.project.id, connection, deps);
+  if (!listed.ok) return { system, ok: false, runId: started.runId, status, reason: listed.reason };
+  const html = firstHtml(listed.files.map((file) => file.name));
+  if (!html) return { system, ok: false, runId: started.runId, status, reason: 'no html file' };
+  const file = await readFile(created.project.id, html, connection, deps);
+  if (!file.ok) return { system, ok: false, runId: started.runId, status, reason: file.reason };
+
+  const dir = `${input.repoRoot.replace(/\/+$/, '')}/design/previews`;
+  const path = `${dir}/${system}.html`;
+  try {
+    deps.mkdir?.(dir);
+    (deps.writeFile ?? (() => { throw new Error('writeFile missing'); }))(path, file.text);
+  } catch {
+    return { system, ok: false, runId: started.runId, status, reason: 'cannot write preview' };
+  }
+  return { system, ok: true, path, runId: started.runId, status };
+}
+
+/** 시스템마다 프로젝트를 만들고 런을 병렬로 기다린다. 한 시스템의 실패는 다른 저장을 막지 않는다. */
+export async function makeDesignPreviews(
+  input: DesignPreviewInput,
+  deps: DesignPreviewDeps = {},
+): Promise<DesignPreviewResult[]> {
+  const connection = deps.connection === undefined ? openDesignConfig(deps) : deps.connection;
+  if (!connection) {
+    return input.systems.map((system) => ({
+      system,
+      ok: false,
+      status: 'unconfigured',
+      reason: 'OpenDesign 이 설정되지 않았다 — design.openDesign.url · tokenFile',
+    }));
+  }
+  const bound: DesignPreviewDeps = {
+    ...deps,
+    mkdir: deps.mkdir ?? ((path: string) => mkdirSync(path, { recursive: true })),
+    writeFile: deps.writeFile ?? ((path: string, contents: string) => writeFileSync(path, contents, 'utf8')),
+  };
+  return Promise.all(input.systems.map((system) => previewOne(input, system, connection, bound)));
+}

package/src/design/design-systems.ts

@@ -0,0 +1,61 @@
+import { readFileSync, readdirSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+import { debug } from '../debug/log.js';
+
+export interface DesignSystem {
+  id: string;
+  name: string;
+  category: string;
+  summary: string;
+  swatch: { bg: string; fg: string; accent: string };
+  fonts: { display: string; body: string };
+  sourceCommit: string;
+}
+
+export function defaultDesignSystemsDir(): string {
+  return resolve(import.meta.dir, '..', '..', 'docs', 'design', 'systems');
+}
+
+export function listDesignSystems(systemsDir: string): DesignSystem[] {
+  let folders: string[];
+  let sourceCommit: string;
+  try {
+    folders = readdirSync(systemsDir, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name);
+    sourceCommit = (JSON.parse(readFileSync(join(systemsDir, 'SOURCE.json'), 'utf8')) as { commit: string }).commit;
+    if (typeof sourceCommit !== 'string' || !sourceCommit) throw new Error('missing source commit');
+  } catch (error) {
+    debug.log('design.systems', 'skipped', { id: 'SOURCE.json', reason: String(error) });
+    return [];
+  }
+
+  const systems: DesignSystem[] = [];
+  for (const id of folders) {
+    try {
+      const dir = join(systemsDir, id);
+      const manifest = JSON.parse(readFileSync(join(dir, 'manifest.json'), 'utf8')) as { id: string; name: string; category: string };
+      if (manifest.id !== id || !manifest.name || !manifest.category) throw new Error('invalid manifest');
+      const document = readFileSync(join(dir, 'DESIGN.md'), 'utf8');
+      const summary = document.split(/\r?\n/).filter((line) => line.startsWith('> '))[1]?.slice(2).trim();
+      if (!summary) throw new Error('missing summary');
+      const cssRaw = readFileSync(join(dir, 'tokens.css'), 'utf8');
+      const css = cssRaw.replace(/\/\*[\s\S]*?\*\//g, '');
+      const root = /:root\s*\{([\s\S]*?)\}/.exec(css)?.[1];
+      if (!root) throw new Error('missing :root tokens');
+      const token = (name: string): string => {
+        const value = new RegExp(`(?:^|\\n)\\s*--${name}\\s*:\\s*([^;\\n]+)\\s*;`, 'm').exec(root)?.[1]?.trim();
+        if (value) return value;
+        if (new RegExp(`/\\*\\s*⚪\\s*--${name}\\s*:`).test(cssRaw)) return '';
+        throw new Error(`missing --${name}`);
+      };
+      systems.push({
+        id, name: manifest.name, category: manifest.category, summary,
+        swatch: { bg: token('bg'), fg: token('fg'), accent: token('accent') },
+        fonts: { display: token('font-display'), body: token('font-body') },
+        sourceCommit,
+      });
+    } catch (error) {
+      debug.log('design.systems', 'skipped', { id, reason: String(error) });
+    }
+  }
+  return systems.sort((a, b) => a.id.localeCompare(b.id));
+}

package/src/design/lint-artifact-run.ts

@@ -5,18 +5,23 @@
 // ⛔ 이 파일은 화면에 «찍지 않는다» — 호출자가 표현을 소유한다.
 
 import { existsSync, readFileSync } from 'node:fs';
-import { dirname, join } from 'node:path';
+import { dirname, join, resolve } from 'node:path';
 
 import { debug } from '../debug/log.js';
-import { reportDesignTokens } from './design-tokens.js';
+import { readCssRootTokens } from './css-root-tokens.js';
+import { reportDesignTokens, type DeclaredToken } from './design-tokens.js';
 import { lintArtifact, type LintResult } from './lint-artifact.js';
 
 export interface LintDesignInput {
   readonly htmlPath: string;
   readonly cssPath?: string;
   readonly designPath?: string;
+  /** 고른 디자인 시스템의 `tokens.css` — 안 주면 씨앗의 `## Design direction` 절 `- tokens:` 줄에서 찾는다. */
+  readonly tokensPath?: string;
 }
 
+export type TokensSource = 'flag' | 'design-direction' | 'none';
+
 export interface LintDesignRun extends LintResult {
   readonly htmlPath: string;
   readonly cssPath: string;
@@ -24,10 +29,31 @@ export interface LintDesignRun extends LintResult {
   readonly cssFound: boolean;
   readonly designPath: string;
   readonly designFound: boolean;
+  readonly tokensPath: string | null;
+  readonly tokensFound: boolean;
+  readonly tokensSource: TokensSource;
+  /** 씨앗 절 토큰 ⊕ `tokens.css` `:root` 토큰(같은 이름이면 씨앗이 이긴다). */
   readonly paletteCount: number;
   readonly typographyCount: number;
 }
 
+/** 씨앗 `## Design direction` 절의 `- tokens: <상대 경로>` — 씨앗 폴더 기준. 없으면 null. */
+export function tokensPathFromDesignDirection(designMarkdown: string, designPath: string): string | null {
+  let inSection = false;
+  for (const line of designMarkdown.split(/\r?\n/)) {
+    if (/^##\s/.test(line)) { inSection = /^##\s+Design direction\s*$/i.test(line); continue; }
+    if (!inSection) continue;
+    const match = /^\s*-\s*tokens:\s*(\S.*?)\s*$/.exec(line);
+    if (match) return resolve(dirname(designPath), match[1]);
+  }
+  return null;
+}
+
+function mergeTokens(primary: readonly DeclaredToken[], secondary: readonly DeclaredToken[]): DeclaredToken[] {
+  const names = new Set(primary.map((t) => t.name));
+  return [...primary, ...secondary.filter((t) => !names.has(t.name))];
+}
+
 /** @throws HTML 을 못 읽으면 던진다 — 호출자가 표현한다. */
 export function runLintDesign(input: LintDesignInput): LintDesignRun {
   try {
@@ -41,23 +67,36 @@ export function runLintDesign(input: LintDesignInput): LintDesignRun {
 
     const designPath = input.designPath ?? join(dirname(input.htmlPath), 'DESIGN.md');
     const designFound = existsSync(designPath);
-    const tokens = designFound ? reportDesignTokens(readFileSync(designPath, 'utf8')) : null;
+    const designMarkdown = designFound ? readFileSync(designPath, 'utf8') : '';
+    const tokens = designFound ? reportDesignTokens(designMarkdown) : null;
+
+    // ⛔ 토큰 파일이 없으면 지금과 «같은» 결과 — 씨앗 절 토큰만 쓴다.
+    const directionTokensPath = designFound ? tokensPathFromDesignDirection(designMarkdown, designPath) : null;
+    const tokensPath = input.tokensPath ?? directionTokensPath;
+    const tokensSource: TokensSource = input.tokensPath !== undefined ? 'flag' : directionTokensPath ? 'design-direction' : 'none';
+    const tokensFound = tokensPath !== null && existsSync(tokensPath);
+    const rootTokens = tokensFound ? readCssRootTokens(readFileSync(tokensPath, 'utf8')) : null;
+    const palette = mergeTokens(tokens?.palette.tokens ?? [], rootTokens?.palette ?? []);
+    const typography = mergeTokens(tokens?.typography.tokens ?? [], rootTokens?.typography ?? []);
 
     const result = lintArtifact({
       html, css,
-      declaredTokens: tokens ? [...tokens.palette.tokens, ...tokens.typography.tokens] : undefined,
+      declaredTokens: tokens || rootTokens ? [...palette, ...typography] : undefined,
     });
 
     const run = {
       ...result,
       htmlPath: input.htmlPath, cssPath, cssFound, designPath, designFound,
-      paletteCount: tokens?.palette.tokens.length ?? 0,
-      typographyCount: tokens?.typography.tokens.length ?? 0,
+      tokensPath, tokensFound, tokensSource,
+      paletteCount: palette.length,
+      typographyCount: typography.length,
     };
     debug.log('design.lint', 'done', {
       htmlPath: run.htmlPath,
       cssPath: run.cssPath,
       designPath: run.designPath,
+      tokensSource: run.tokensSource,
+      tokensFound: run.tokensFound,
       p0Count: run.p0Count,
       advisoryCount: run.advisoryCount,
       uncheckedRuleCount: run.skipped.length,
@@ -75,6 +114,7 @@ export function formatLintDesignRun(r: LintDesignRun): string[] {
     `◆ design-lint — ${r.htmlPath}`,
     `  CSS     ${r.cssFound ? r.cssPath : '🔴 못 찾았다 — CSS 규칙은 «검사 안 됨»이다'}`,
     `  씨앗    ${r.designFound ? `${r.designPath} (토큰 ${r.paletteCount}색 · ${r.typographyCount}타이포)` : '🔴 없다 — 씨앗 의존 규칙은 «검사 안 됨»'}`,
+    `  토큰    ${r.tokensPath === null ? '없음 (방향 절에 tokens 줄이 없다)' : `${r.tokensFound ? r.tokensPath : `🔴 못 찾았다 — ${r.tokensPath}`} (출처 ${r.tokensSource})`}`,
     `  ── 결과 ──`,
     `  ⛔ P0 위반   ${r.p0Count}`,
     `  ⚠️ advisory  ${r.advisoryCount}`,

package/src/design/lint-artifact.ts

@@ -164,7 +164,11 @@ export function lintArtifact(input: LintInput): LintResult {
   // ⑤ 라운드 카드 + 색깔 좌측 보더 — ⛔ «같은 규칙 블록» 안에서만 본다
   for (const m of css.matchAll(/\{[^}]*\}/g)) {
     const b = m[0];
-    if (/border-radius\s*:\s*(?!0)/.test(b) && /border-left\s*:\s*[^;]*(#|rgb|var\()/.test(b)) {
+    // 🩸 2026-09-28 E0·E1: 두 판 모두 «커피콩 그림»(`border-radius: 50%` 타원 ⊕ 한쪽 선)에 걸렸다.
+    //    카드 타일은 둥근 «모서리»지 타원이 아니다 — 30% 이상 퍼센트·`/` 타원 반경은 그림으로 보고 뺀다.
+    const radius = /border-radius\s*:\s*([^;}]*)/.exec(b)?.[1] ?? '';
+    const shape = radius.includes('/') || [...radius.matchAll(/(\d+(?:\.\d+)?)%/g)].some((p) => Number(p[1]) >= 30);
+    if (/border-radius\s*:\s*(?!0)/.test(b) && !shape && /border-left\s*:\s*[^;]*(#|rgb|var\()/.test(b)) {
       push('rounded-card-left-accent', 'p0', { line: lineOf(css, m.index ?? 0), evidence: b.replace(/\s+/g, ' ').slice(0, 90) },
         '라운드 + 색 좌측 보더는 전형적 「AI 대시보드 타일」이다 — 둘 중 하나를 뺀다');
     }