@gaonjs/cli 0.31.1 → 0.33.0

package/dist/dev/frontend-build.js

@@ -1,5 +1,5 @@
 /**
- * @gaonjs/cli · dev/frontend-build — 프론트 번들 watch 빌드 (결정 67 · M9-C)
+ * @gaonjs/cli · dev/frontend-build — 멀티 앱 프론트 번들 watch 빌드 (결정 67 · 결정 146)
  *
  * `gaon dev` 는 서버(serve)를 재시작 방식으로 띄운다(§dev.ts). 프론트 번들은
  * serve 가 dist/<앱>/index.html 을 매 요청 읽어 문서 셸에 이어 붙이므로
@@ -7,50 +7,55 @@
  * watch 모드로 함께 돌린다. 진짜 HMR(모듈 교체)은 v1 어댑터 범위 밖이라(§6.4)
  * "저장 → 재빌드 → 새로고침" 루프를 제공한다.
  *
- * fail-open: apps/web/index.html·vite 가 없으면 조용히 건너뛴다(프론트 없는
- * API 전용 프로젝트도 gaon dev 가 동작해야 한다). vite 실행 실패는 통합
- * 콘솔에 알리되 dev 전체를 막지 않는다.
+ * 결정 146(12차 W2): apps/* 를 순회해 **앱마다** watch 빌드한다(root=apps/<앱>·
+ * outDir=dist/<앱>·base=/<앱>/). 예전엔 apps/web 하나만 감시해 둘째 앱(admin)의
+ * dist 가 dev 에서 갱신되지 않았다. 프로그램적 build(configFile 명시)로 vue 플러그인
+ * 누락 함정을 피한다.
+ *
+ * fail-open: 프론트 진입(index.html)·vite 가 없으면 조용히 건너뛴다(프론트 없는
+ * API 전용 프로젝트도 gaon dev 가 동작해야 한다). vite 실패는 통합 콘솔에 알리되
+ * dev 전체를 막지 않는다.
  */
-import { spawn } from 'node:child_process';
-import { existsSync } from 'node:fs';
-import { join, resolve } from 'node:path';
-/** 프로젝트에 프론트 진입 HTML(apps/web/index.html)이 있는가. */
-function hasFrontend(cwd) {
-    return existsSync(join(cwd, 'apps', 'web', 'index.html'));
-}
-/** cwd 의 로컬 vite bin 을 찾는다(없으면 undefined — 건너뜀). */
-function resolveViteBin(cwd) {
-    const bin = join(cwd, 'node_modules', '.bin', 'vite');
-    return existsSync(bin) ? bin : undefined;
-}
+import { resolve } from 'node:path';
+import { appBase, buildApp, listFrontendApps } from './build.js';
 /**
- * vite build --watch 를 띄운다. 프론트가 없거나 vite 가 없으면 아무 것도 하지
- * 않고 no-op 핸들을 돌려준다(dev 는 계속 진행).
+ * apps/* 를 순회해 앱마다 vite watch 빌드를 띄운다. 프론트가 없거나 vite 가 없으면
+ * 아무 것도 하지 않고 no-op 핸들을 돌려준다(dev 는 계속 진행 · fail-open).
  */
 export function startFrontendBuild(opts) {
     const cwd = resolve(opts.cwd);
-    if (!hasFrontend(cwd)) {
-        opts.onLog('프론트 진입 HTML(apps/web/index.html)이 없어 vite 빌드를 건너뜁니다.', 'info');
-        return { close() { } };
-    }
-    const bin = resolveViteBin(cwd);
-    if (!bin) {
-        opts.onLog('vite 를 찾지 못해 프론트 watch 빌드를 건너뜁니다 → pnpm add -D vite @vitejs/plugin-vue', 'warn');
-        return { close() { } };
-    }
-    const child = spawn(bin, ['build', '--watch'], {
-        cwd,
-        stdio: ['ignore', 'pipe', 'pipe'],
-        env: { ...process.env },
+    const watchers = [];
+    let closed = false;
+    void (async () => {
+        const apps = await listFrontendApps(cwd);
+        if (apps.length === 0) {
+            opts.onLog('프론트 진입 HTML(apps/<앱>/index.html)이 없어 vite watch 빌드를 건너뜁니다.', 'info');
+            return;
+        }
+        for (const app of apps) {
+            if (closed)
+                break;
+            opts.onLog(`▶ vite build --watch — apps/${app} → dist/${app} (base=${appBase(app)})`, 'info');
+            try {
+                const handle = await buildApp(cwd, app, { watch: true, onLog: opts.onLog });
+                if (closed) {
+                    await handle.close();
+                    break;
+                }
+                watchers.push(handle);
+            }
+            catch (err) {
+                opts.onLog(`vite watch 빌드를 건너뜁니다(apps/${app}): ${err instanceof Error ? err.message : String(err)}`, 'warn');
+            }
+        }
+    })().catch((err) => {
+        opts.onLog(`프론트 watch 빌드 오류: ${err instanceof Error ? err.message : String(err)}`, 'error');
     });
-    child.stdout?.on('data', (b) => opts.onLog(b.toString().trimEnd(), 'info'));
-    child.stderr?.on('data', (b) => opts.onLog(b.toString().trimEnd(), 'error'));
-    child.on('error', (err) => opts.onLog(`vite 실행 실패: ${err.message}`, 'error'));
-    opts.onLog('▶ vite build --watch — 프론트 번들 감시 (dist/web)', 'info');
     return {
         close() {
-            if (child.exitCode === null && child.signalCode === null)
-                child.kill('SIGTERM');
+            closed = true;
+            for (const w of watchers)
+                void w.close();
         },
     };
 }

package/dist/doctor/async-offload.d.ts

@@ -1,5 +1,7 @@
 import type { RuleReport } from './types.js';
-/** app.config 소스가 JWT/API 앱인가 (외부 HTTP arm 제외 대상 · csrf-wiring 과 동일 판정). */
+/** app.config 소스가 JWT/API 앱인가 (외부 HTTP arm 제외 대상 · csrf-wiring 과 동일 판정).
+ *  결정 140(12차 W1): jwt 판정을 usesJwtStrategy 한 곳으로 통일 — 주석의
+ *  `// strategy: 'jwt'` 오탐이 offload 검사를 잘못 끄지 않도록. */
 export declare function isApiApp(appConfigSource: string): boolean;
 /** 파일이 메일 SDK 를 직접 import 하는가(단위 테스트 진입점). */
 export declare function importsMailSdk(source: string): boolean;

package/dist/doctor/async-offload.js

@@ -28,6 +28,7 @@ import { readdir, readFile } from 'node:fs/promises';
 import { existsSync } from 'node:fs';
 import { join, relative } from 'node:path';
 import ts from 'typescript';
+import { usesJwtStrategy } from './auth-wiring.js';
 // ── 검출 시그니처 ─────────────────────────────────────────────────────
 /** 메일 SDK 모듈 import (컨트롤러 = 잡 발행만 · async.md 함정 · async-flow forbidden 동일 집합). */
 const MAIL_SDK_IMPORT = /import\s+[\s\S]*?\bfrom\s+['"](?:nodemailer|resend|@sendgrid\/mail|mailgun[.\-/][^'"]*|mailgun)['"]/;
@@ -44,9 +45,11 @@ const EXTERNAL_HTTP = [
     // axios('https://...') · axios.get('https://...') · axios({ url: 'https://...' })
     /\baxios\s*(?:\.\s*(?:get|post|put|patch|delete|request|head)\s*)?\(\s*(?:\{[\s\S]*?\burl\s*:\s*)?[`'"]https?:\/\/(?!localhost|127\.0\.0\.1)/i,
 ];
-/** app.config 소스가 JWT/API 앱인가 (외부 HTTP arm 제외 대상 · csrf-wiring 과 동일 판정). */
+/** app.config 소스가 JWT/API 앱인가 (외부 HTTP arm 제외 대상 · csrf-wiring 과 동일 판정).
+ *  결정 140(12차 W1): jwt 판정을 usesJwtStrategy 한 곳으로 통일 — 주석의
+ *  `// strategy: 'jwt'` 오탐이 offload 검사를 잘못 끄지 않도록. */
 export function isApiApp(appConfigSource) {
-    return /strategy\s*:\s*['"]jwt['"]/.test(appConfigSource);
+    return usesJwtStrategy(appConfigSource);
 }
 /** 파일이 메일 SDK 를 직접 import 하는가(단위 테스트 진입점). */
 export function importsMailSdk(source) {

package/dist/doctor/auth-wiring.d.ts

@@ -1,9 +1,11 @@
 import type { RuleReport } from './types.js';
 /** 컨트롤러 소스가 인증 표면을 쓰는지 판정한다(단위 테스트 진입점). */
 export declare function usesAuthSurface(source: string): boolean;
-/** app.config.ts 소스에 auth 배선이 있는지(얕은 텍스트 판정). */
+/** app.config.ts 소스에 auth 배선이 있는지(주석/문자열 제외 후 판정). */
 export declare function hasAuthWiring(source: string): boolean;
-/** app.config.ts 소스에 session 배선이 있는지(얕은 텍스트 판정). */
+/** app.config.ts 소스에 session 배선이 있는지(주석/문자열 제외 후 판정). */
 export declare function hasSessionWiring(source: string): boolean;
+/** app.config.ts 소스가 JWT 전략(strategy:'jwt')인지(주석 제외 후 판정 · 문자열 내용 보존). */
+export declare function usesJwtStrategy(source: string): boolean;
 /** apps/ 를 훑어 인증 배선 누락을 낸다. */
 export declare function checkAuthWiring(cwd: string): Promise<RuleReport>;

package/dist/doctor/auth-wiring.js

@@ -11,17 +11,24 @@
 import { readdir, readFile } from 'node:fs/promises';
 import { existsSync } from 'node:fs';
 import { join, relative } from 'node:path';
+import { stripComments, stripCommentsAndStrings } from './source-scan.js';
+// 결정 140(12차 W1): 판정 전 주석/문자열을 지운다. `// session:` 주석이나 문자열
+// 안의 우연한 일치가 배선으로 오탐되면 보안 검사(세션·CSRF)가 통째로 skip 된다.
 /** 컨트롤러 소스가 인증 표면을 쓰는지 판정한다(단위 테스트 진입점). */
 export function usesAuthSurface(source) {
-    return /this\.requireAuth\s*\(|this\.auth\.login\s*\(|this\.currentUser\b/.test(source);
+    return /this\.requireAuth\s*\(|this\.auth\.login\s*\(|this\.currentUser\b/.test(stripCommentsAndStrings(source));
 }
-/** app.config.ts 소스에 auth 배선이 있는지(얕은 텍스트 판정). */
+/** app.config.ts 소스에 auth 배선이 있는지(주석/문자열 제외 후 판정). */
 export function hasAuthWiring(source) {
-    return /\bauth\s*:/.test(source);
+    return /\bauth\s*:/.test(stripCommentsAndStrings(source));
 }
-/** app.config.ts 소스에 session 배선이 있는지(얕은 텍스트 판정). */
+/** app.config.ts 소스에 session 배선이 있는지(주석/문자열 제외 후 판정). */
 export function hasSessionWiring(source) {
-    return /\bsession\s*:/.test(source);
+    return /\bsession\s*:/.test(stripCommentsAndStrings(source));
+}
+/** app.config.ts 소스가 JWT 전략(strategy:'jwt')인지(주석 제외 후 판정 · 문자열 내용 보존). */
+export function usesJwtStrategy(source) {
+    return /strategy\s*:\s*['"]jwt['"]/.test(stripComments(source));
 }
 /** apps/ 를 훑어 인증 배선 누락을 낸다. */
 export async function checkAuthWiring(cwd) {
@@ -42,7 +49,7 @@ export async function checkAuthWiring(cwd) {
         const acPath = join(appsDir, app, 'app.config.ts');
         const acRel = relative(cwd, acPath);
         const acSource = existsSync(acPath) ? await readFile(acPath, 'utf8') : undefined;
-        const jwt = acSource != null && /strategy\s*:\s*['"]jwt['"]/.test(acSource);
+        const jwt = acSource != null && usesJwtStrategy(acSource);
         if (acSource == null || !hasAuthWiring(acSource)) {
             issues.push({
                 rule: 'auth-wiring',

package/dist/doctor/connections.d.ts

@@ -5,7 +5,29 @@ interface KeyUse {
     readonly line: number;
     readonly kind: 'table' | 'getConnection';
 }
-/** gaon.config.ts 를 정적 AST 로 파싱해 db 커넥션 키 목록을 뽑는다. */
+/** gaon.config.ts 정적 분석 결과(결정 135). keys = 뽑아낸 커넥션 키, dbDeclared =
+ * db 프로퍼티 존재 여부, unanalyzable = db 초기화식에 정적으로 못 읽는 부분(식별자
+ * 참조·함수 호출 등)이 섞여 있었는지. unanalyzable 이면 커넥션 검사가 커버리지를
+ * 보장할 수 없어 doctor 가 안내를 낸다(W2). */
+export interface ConfigDbAnalysis {
+    readonly keys: string[];
+    readonly dbDeclared: boolean;
+    readonly unanalyzable: boolean;
+}
+/**
+ * gaon.config.ts 를 정적 AST 로 파싱해 db 커넥션 키를 분석한다(결정 135 · W2).
+ *
+ * 객체 리터럴뿐 아니라 스캐폴드·실사용에서 흔한 형태를 모두 훑는다:
+ *  - `db: { main: {...} }`                         → ['main']
+ *  - `db: process.env.X ? { main:{...} } : undefined` → 삼항 양 분기(결정 135)
+ *  - `db: cfg ?? { main:{...} }` · `a && { ... }`   → ?? · && · || 양변
+ *  - `db: ({ main:{...} })`                          → 괄호 벗김
+ *  - `db: { main, legacy }`(shorthand)              → ['main','legacy']
+ * 못 읽는 형태(식별자 참조·함수 호출·스프레드)는 unanalyzable=true 로 표시한다 —
+ * "키 0" 로 조용히 통과시키던(main 폴백) 스캐폴드 삼항 사각(W2 근본)을 없앤다.
+ */
+export declare function analyzeConfigDb(source: string): ConfigDbAnalysis;
+/** 하위 호환 — db 커넥션 키만 돌려준다(analyzeConfigDb 위임). */
 export declare function extractConfigDbKeys(source: string): string[];
 /** 소스에서 table(name, defs, { db: 'X' }) 와 getConnection('X') 호출을 추출한다. */
 export declare function extractKeyUses(cwd: string, file: string, source: string): KeyUse[];

package/dist/doctor/connections.js

@@ -13,26 +13,77 @@ import { existsSync } from 'node:fs';
 import { readdir, readFile } from 'node:fs/promises';
 import { join, relative } from 'node:path';
 import ts from 'typescript';
-/** gaon.config.ts 를 정적 AST 로 파싱해 db 커넥션 키 목록을 뽑는다. */
-export function extractConfigDbKeys(source) {
+/**
+ * gaon.config.ts 를 정적 AST 로 파싱해 db 커넥션 키를 분석한다(결정 135 · W2).
+ *
+ * 객체 리터럴뿐 아니라 스캐폴드·실사용에서 흔한 형태를 모두 훑는다:
+ *  - `db: { main: {...} }`                         → ['main']
+ *  - `db: process.env.X ? { main:{...} } : undefined` → 삼항 양 분기(결정 135)
+ *  - `db: cfg ?? { main:{...} }` · `a && { ... }`   → ?? · && · || 양변
+ *  - `db: ({ main:{...} })`                          → 괄호 벗김
+ *  - `db: { main, legacy }`(shorthand)              → ['main','legacy']
+ * 못 읽는 형태(식별자 참조·함수 호출·스프레드)는 unanalyzable=true 로 표시한다 —
+ * "키 0" 로 조용히 통과시키던(main 폴백) 스캐폴드 삼항 사각(W2 근본)을 없앤다.
+ */
+export function analyzeConfigDb(source) {
     const sf = ts.createSourceFile('gaon.config.ts', source, ts.ScriptTarget.ES2022, true);
     const keys = [];
+    let dbDeclared = false;
+    let unanalyzable = false;
+    const collect = (node) => {
+        if (ts.isParenthesizedExpression(node))
+            return collect(node.expression);
+        if (ts.isObjectLiteralExpression(node)) {
+            for (const dp of node.properties) {
+                if (ts.isPropertyAssignment(dp)) {
+                    const n = propNameText(dp.name);
+                    if (n)
+                        keys.push(n);
+                    else
+                        unanalyzable = true; // 계산된 키 등
+                }
+                else if (ts.isShorthandPropertyAssignment(dp)) {
+                    keys.push(dp.name.text);
+                }
+                else {
+                    unanalyzable = true; // 스프레드·메서드 등
+                }
+            }
+            return;
+        }
+        if (ts.isConditionalExpression(node)) {
+            collect(node.whenTrue);
+            collect(node.whenFalse);
+            return;
+        }
+        if (ts.isBinaryExpression(node)) {
+            const op = node.operatorToken.kind;
+            if (op === ts.SyntaxKind.QuestionQuestionToken ||
+                op === ts.SyntaxKind.BarBarToken ||
+                op === ts.SyntaxKind.AmpersandAmpersandToken) {
+                collect(node.left);
+                collect(node.right);
+                return;
+            }
+            unanalyzable = true;
+            return;
+        }
+        // `undefined` · `null` 분기 = 커넥션 없음(분석 가능 · 키 기여 0).
+        if (node.kind === ts.SyntaxKind.NullKeyword)
+            return;
+        if (ts.isIdentifier(node) && node.text === 'undefined')
+            return;
+        // 그 외(식별자 참조·함수 호출 등) = 정적으로 못 읽음.
+        unanalyzable = true;
+    };
     const visit = (node) => {
-        // defineConfig({ db: { main: {...}, legacy: {...} } })
         if (ts.isCallExpression(node) && isDefineConfig(node.expression)) {
             const arg = node.arguments[0];
             if (arg && ts.isObjectLiteralExpression(arg)) {
                 for (const p of arg.properties) {
                     if (ts.isPropertyAssignment(p) && propNameText(p.name) === 'db') {
-                        if (ts.isObjectLiteralExpression(p.initializer)) {
-                            for (const dp of p.initializer.properties) {
-                                if (ts.isPropertyAssignment(dp)) {
-                                    const n = propNameText(dp.name);
-                                    if (n)
-                                        keys.push(n);
-                                }
-                            }
-                        }
+                        dbDeclared = true;
+                        collect(p.initializer);
                     }
                 }
             }
@@ -40,7 +91,11 @@ export function extractConfigDbKeys(source) {
         ts.forEachChild(node, visit);
     };
     visit(sf);
-    return keys;
+    return { keys, dbDeclared, unanalyzable };
+}
+/** 하위 호환 — db 커넥션 키만 돌려준다(analyzeConfigDb 위임). */
+export function extractConfigDbKeys(source) {
+    return analyzeConfigDb(source).keys;
 }
 function isDefineConfig(e) {
     if (ts.isIdentifier(e) && e.text === 'defineConfig')
@@ -107,8 +162,24 @@ export async function checkConnections(cwd) {
     const configPath = findConfigPath(cwd);
     if (configPath) {
         const src = await readFile(configPath, 'utf8');
-        for (const k of extractConfigDbKeys(src))
+        const analysis = analyzeConfigDb(src);
+        for (const k of analysis.keys)
             registered.add(k);
+        // W2(결정 135): db 가 선언됐는데 정적으로 못 읽는 형태면 커넥션 검사가
+        // 등록 키를 놓쳐 오탐/사각이 생긴다 — "main 만 허용" 으로 조용히 통과하지 말고
+        // 안내한다(에러 = 수리 안내서 · §7.5.3).
+        if (analysis.dbDeclared && analysis.unanalyzable) {
+            issues.push({
+                rule: 'connections',
+                level: 'warning',
+                file: relative(cwd, configPath),
+                message: `gaon.config.ts 의 db 설정을 정적으로 읽지 못했습니다 — 커넥션 키 검사가 불완전할 수 있습니다.\n` +
+                    `읽어낸 키: ${analysis.keys.length ? analysis.keys.join(', ') : '(없음)'}\n` +
+                    `→ db 를 리터럴 객체로 두세요(키는 리터럴 · 값만 env). 예:\n` +
+                    `    db: { main: { adapter: 'postgres', url: process.env.DATABASE_URL ?? '' } }`,
+                detail: { kind: 'unanalyzable-db', keys: analysis.keys },
+            });
+        }
     }
     const files = [];
     await collectTsFiles(join(cwd, 'domain'), files);

package/dist/doctor/csrf-wiring.d.ts

@@ -1,5 +1,7 @@
 import type { RuleReport } from './types.js';
-/** routes.ts 소스에 상태 변경(비-GET) 라우트가 있는지 판정한다(단위 테스트 진입점). */
+/** routes.ts 소스에 상태 변경(비-GET) 라우트가 있는지 판정한다(단위 테스트 진입점).
+ *  결정 140(12차 W1): 주석/문자열 안의 우연한 일치가 CSRF 검사를 왜곡하지 않도록
+ *  판정 전 정규화한다(여는 따옴표 구분자는 보존되어 라우트 매칭은 유지). */
 export declare function hasStateChangingRoutes(routesSource: string): boolean;
 /** apps/ 를 훑어 CSRF/세션 미배선(비-GET 라우트 + session 없음)을 경고로 낸다. */
 export declare function checkCsrfWiring(cwd: string): Promise<RuleReport>;

package/dist/doctor/csrf-wiring.js

@@ -14,14 +14,18 @@
 import { readdir, readFile } from 'node:fs/promises';
 import { existsSync } from 'node:fs';
 import { join, relative } from 'node:path';
-import { hasSessionWiring } from './auth-wiring.js';
-/** routes.ts 소스에 상태 변경(비-GET) 라우트가 있는지 판정한다(단위 테스트 진입점). */
+import { hasSessionWiring, usesJwtStrategy } from './auth-wiring.js';
+import { stripCommentsAndStrings } from './source-scan.js';
+/** routes.ts 소스에 상태 변경(비-GET) 라우트가 있는지 판정한다(단위 테스트 진입점).
+ *  결정 140(12차 W1): 주석/문자열 안의 우연한 일치가 CSRF 검사를 왜곡하지 않도록
+ *  판정 전 정규화한다(여는 따옴표 구분자는 보존되어 라우트 매칭은 유지). */
 export function hasStateChangingRoutes(routesSource) {
+    const src = stripCommentsAndStrings(routesSource);
     // r.post('/x', ...) · r.put/patch/delete — 메서드 + 경로 문자열.
-    if (/\.\s*(post|put|patch|delete)\s*\(\s*['"]/.test(routesSource))
+    if (/\.\s*(post|put|patch|delete)\s*\(\s*['"]/.test(src))
         return true;
     // resource(s)('posts') — 리소스 라우트는 create/update/destroy(POST/PUT/DELETE)를 만든다.
-    if (/\.\s*resources?\s*\(\s*['"]/.test(routesSource))
+    if (/\.\s*resources?\s*\(\s*['"]/.test(src))
         return true;
     return false;
 }
@@ -40,7 +44,7 @@ export async function checkCsrfWiring(cwd) {
         const acRel = relative(cwd, acPath);
         const acSource = existsSync(acPath) ? await readFile(acPath, 'utf8') : undefined;
         // JWT/API 앱은 토큰 인증 — CSRF 대상 아님(제외).
-        const jwt = acSource != null && /strategy\s*:\s*['"]jwt['"]/.test(acSource);
+        const jwt = acSource != null && usesJwtStrategy(acSource);
         if (jwt)
             continue;
         if (acSource != null && hasSessionWiring(acSource))

package/dist/doctor/schema-relations.d.ts

@@ -0,0 +1,7 @@
+import type { RuleReport } from './types.js';
+/**
+ * 프로젝트 전체의 §4.5 관계 제약을 검사한다. domain/schema 가 없으면 통과.
+ * 스키마 로드 실패(문법 오류 등)는 이 검사만 warning 으로 강등하고 안내한다 —
+ * connections(static)·gaon check(typecheck)가 별도로 원인을 짚는다.
+ */
+export declare function checkSchemaRelations(cwd: string): Promise<RuleReport>;

package/dist/doctor/schema-relations.js

@@ -0,0 +1,114 @@
+// @gaonjs/cli · doctor · 스키마 관계 검사 배선 (§4.5 · 결정 134)
+//
+// @gaonjs/data 의 checkCrossConnectionRelations·checkRelationTargets 를 `gaon
+// doctor` 러너에 배선한다. 이 검사들은 이미 data 패키지에 구현+테스트가 완비돼
+// 있었으나 CLI 러너가 호출하지 않아 커넥션을 가로지르는 belongsTo 가 doctor 로
+// 잡히지 않고 배포 후 raw postgres 에러로만 드러났다 — "미구현"이 아니라
+// "배선 안 됨"(§13.9 "단위 green ≠ 개발자 도달" 4번째 사례 · 결정 134).
+//
+// connections 검사(static AST)와 달리 관계 그래프는 TableDef 값(참조 컬럼·db
+// 키·역방향 관계)이 필요하다. 그래서 domain/schema/*.ts 를 실제 로드해 TableDef[]
+// 를 모은다 — `gaon db diff`·`migrate` 와 같은 스키마 로드 경로(scanSchemaDir).
+// 커넥션으로 걸러내지 않고 **전 커넥션 테이블을 함께** 봐야 커넥션을 가로지르는
+// belongsTo 를 검출할 수 있다(resolve.ts scanTables 는 단일 dbKey 로 거르므로 부적합).
+import { existsSync } from 'node:fs';
+import { join, relative } from 'node:path';
+import { scanSchemaDir, checkCrossConnectionRelations, checkRelationTargets, } from '@gaonjs/data';
+import { registerTsResolve } from '../tsResolve.js';
+/** TableDef 판별 — scanSchemaDir 이 준 모듈 네임스페이스에서 table() 산출만 고른다. */
+function isTableDef(v) {
+    return (typeof v === 'object' &&
+        v !== null &&
+        'name' in v &&
+        'defs' in v &&
+        'db' in v &&
+        typeof v.name === 'string');
+}
+/**
+ * domain/schema/ 의 모든 TableDef 를 커넥션 구분 없이 로드하고, 각 테이블이
+ * 어느 소스 파일에서 왔는지 함께 기록한다(진단에 파일 위치를 붙이기 위함).
+ */
+async function loadAllTables(cwd, schemaDir) {
+    registerTsResolve();
+    // outDir 은 import 지정자 계산에만 쓰이고 파일을 쓰지 않는다(resolve.ts 관례).
+    const outDir = join(cwd, '.gaon');
+    const modules = await scanSchemaDir(schemaDir, outDir);
+    const tables = [];
+    const fileOf = new Map();
+    for (const mod of modules) {
+        // importPath 는 .gaon 기준 상대(./../domain/schema/x.js) — 사람이 읽을 프로젝트
+        // 상대 경로로 정규화한다(진단 file 필드는 cwd 상대 관례).
+        const relFile = importPathToProjectRel(cwd, outDir, mod.importPath);
+        for (const [, value] of Object.entries(mod.ns)) {
+            if (isTableDef(value)) {
+                tables.push(value);
+                if (!fileOf.has(value.name))
+                    fileOf.set(value.name, relFile);
+            }
+        }
+    }
+    tables.sort((a, b) => a.name.localeCompare(b.name));
+    return { tables, fileOf };
+}
+/** scanSchemaDir 의 importPath(.gaon 기준, .js)를 cwd 상대 .ts 경로로 되돌린다. */
+function importPathToProjectRel(cwd, outDir, importPath) {
+    const abs = join(outDir, importPath).replace(/\.js$/, '.ts');
+    return relative(cwd, abs).replace(/\\/g, '/');
+}
+/** data 의 Diagnostic 를 doctor 의 DoctorCheck 로 변환한다(§4.5 → RuleReport 정합). */
+function toCheck(d, fileOf, owner) {
+    const file = fileOf.get(owner);
+    return {
+        rule: 'schema-relations',
+        level: d.level === 'warning' ? 'warning' : 'error',
+        message: d.message,
+        ...(file ? { file } : {}),
+        detail: { code: d.code, table: owner },
+    };
+}
+/**
+ * 관계 진단이 어느 테이블 소유인지를 message 앞머리(`<table>.<...>`)에서 뽑아
+ * 파일을 붙인다. 관계·컬럼 검사 모두 "테이블명.멤버 …" 로 시작한다.
+ */
+function ownerOf(message) {
+    const m = message.match(/^([A-Za-z0-9_]+)\./);
+    return m ? m[1] : '';
+}
+/**
+ * 프로젝트 전체의 §4.5 관계 제약을 검사한다. domain/schema 가 없으면 통과.
+ * 스키마 로드 실패(문법 오류 등)는 이 검사만 warning 으로 강등하고 안내한다 —
+ * connections(static)·gaon check(typecheck)가 별도로 원인을 짚는다.
+ */
+export async function checkSchemaRelations(cwd) {
+    const schemaDir = join(cwd, 'domain', 'schema');
+    if (!existsSync(schemaDir))
+        return { rule: 'schema-relations', issues: [] };
+    let tables;
+    let fileOf;
+    try {
+        ;
+        ({ tables, fileOf } = await loadAllTables(cwd, schemaDir));
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        return {
+            rule: 'schema-relations',
+            issues: [
+                {
+                    rule: 'schema-relations',
+                    level: 'warning',
+                    message: `스키마 관계 검사를 건너뜁니다 — domain/schema 로드 실패: ${msg}\n` +
+                        `→ 'gaon check' 로 타입 오류를 먼저 확인하세요(스키마가 컴파일되면 이 검사가 활성화됩니다).`,
+                    detail: { skipped: true },
+                },
+            ],
+        };
+    }
+    // data 패키지 구현을 그대로 호출한다(재구현 금지 · 결정 134).
+    const diags = [
+        ...checkCrossConnectionRelations(tables),
+        ...checkRelationTargets(tables),
+    ];
+    const issues = diags.map((d) => toCheck(d, fileOf, ownerOf(d.message)));
+    return { rule: 'schema-relations', issues };
+}

package/dist/doctor/seal-security.js

@@ -10,10 +10,13 @@
 import { readdir, readFile } from 'node:fs/promises';
 import { existsSync } from 'node:fs';
 import { join } from 'node:path';
+import { stripComments, stripCommentsAndStrings } from './source-scan.js';
+// 결정 140(12차 W1): 판정 전 주석/문자열을 지운다 — 주석의 `seal: {` 나 문자열 안의
+// 우연한 일치가 검사를 왜곡하지 않도록.
 /** app.config.ts 소스에 seal 토글(true 또는 { … })이 켜져 있는지 판정한다(단위 테스트 진입점). */
 export function hasSealEnabled(appConfigSource) {
     // seal: true · seal: { except: [...] } — false/생략은 제외.
-    return /\bseal\s*:\s*(true|\{)/.test(appConfigSource);
+    return /\bseal\s*:\s*(true|\{)/.test(stripCommentsAndStrings(appConfigSource));
 }
 /**
  * 결정 121(§3.1): seal 앱의 main.ts 가 seal 클라이언트를 배선했는지 판정한다(단위 테스트 진입점).
@@ -22,19 +25,22 @@ export function hasSealEnabled(appConfigSource) {
  * (seal-browser-e2e 로 실측). import + sealClient 전달을 둘 다 확인한다.
  */
 export function hasSealClientWired(mainSource) {
-    const imported = /import[^\n]*@gaonjs\/seal\/client/.test(mainSource);
+    // import 경로 문자열을 봐야 하므로 문자열 내용은 보존(주석만 제거).
+    const src = stripComments(mainSource);
+    const imported = /import[^\n]*@gaonjs\/seal\/client/.test(src);
     // createGaonApp(...) 호출 안에 sealClient 가 실제로 전달됐는지(멀티라인 객체 허용).
-    const passed = /createGaonApp\s*\([\s\S]*\bsealClient\b/.test(mainSource);
+    const passed = /createGaonApp\s*\([\s\S]*\bsealClient\b/.test(src);
     return imported && passed;
 }
 /** gaon.config.ts 소스에서 명시적으로 꺼진 보안 방어층 이름을 뽑는다(rateLimit·securityHeaders·cors). */
 export function disabledDefenses(gaonConfigSource) {
+    const src = stripCommentsAndStrings(gaonConfigSource);
     const off = [];
-    if (/\brateLimit\s*:\s*false/.test(gaonConfigSource))
+    if (/\brateLimit\s*:\s*false/.test(src))
         off.push('rateLimit');
-    if (/\bsecurityHeaders\s*:\s*false/.test(gaonConfigSource))
+    if (/\bsecurityHeaders\s*:\s*false/.test(src))
         off.push('securityHeaders');
-    if (/\bcors\s*:\s*false/.test(gaonConfigSource))
+    if (/\bcors\s*:\s*false/.test(src))
         off.push('cors');
     return off;
 }

package/dist/doctor/source-scan.d.ts

@@ -0,0 +1,11 @@
+/**
+ * 주석을 지운 소스를 돌려준다(문자열·코드는 보존 · 라인 번호 유지).
+ * 문자열 **내용**을 봐야 하는 탐지기(예: `strategy: 'jwt'` · import 경로)에 쓴다.
+ */
+export declare function stripComments(source: string): string;
+/**
+ * 주석 + 문자열/템플릿 리터럴 내용을 지운 소스를 돌려준다(구분자·라인 보존).
+ * 프로퍼티 키·키워드만 보는 탐지기(예: `session:` · `auth:` · `rateLimit: false`)에
+ * 쓴다 — 주석도 문자열도 키를 위장하지 못한다.
+ */
+export declare function stripCommentsAndStrings(source: string): string;

package/dist/doctor/source-scan.js

@@ -0,0 +1,70 @@
+// @gaonjs/cli · doctor · 소스 정규화 유틸 (12차 W1 · 결정 140)
+//
+// 탐지기가 정규식으로 소스를 볼 때 **주석·문자열 안의 우연한 일치**를 배선으로
+// 오탐하지 않도록, TS 스캐너로 토큰을 훑어 주석/문자열을 안전하게 지운다.
+//
+// 왜 스캐너인가(regex 스트립이 아니라): 보안 탐지기(auth·csrf·seal)는 오탐이
+// 검사 skip = 취약점 노출로 이어진다(12차 W1 · gaon g app 스캐폴드의 주석
+// `//   session: { ... }` 가 hasSessionWiring 을 만족시켜 CSRF/세션 검사를
+// 통째로 건너뛴 P0). regex 기반 주석 스트립은 문자열 안의 `//` 를 잘못 지우는
+// 등 경계에서 새므로, 정확한 토큰 경계가 필요한 보안 탐지기는 스캐너로 지운다.
+// (connections.ts·schema-relations.ts 가 이미 TS AST 를 쓰는 것과 같은 결.)
+//
+// 라인/컬럼(개행)은 보존한다 — 탐지기가 라인 번호를 그대로 보고할 수 있게.
+import ts from 'typescript';
+function isCommentKind(k) {
+    return k === ts.SyntaxKind.SingleLineCommentTrivia || k === ts.SyntaxKind.MultiLineCommentTrivia;
+}
+function isStringKind(k) {
+    return (k === ts.SyntaxKind.StringLiteral ||
+        k === ts.SyntaxKind.NoSubstitutionTemplateLiteral ||
+        k === ts.SyntaxKind.TemplateHead ||
+        k === ts.SyntaxKind.TemplateMiddle ||
+        k === ts.SyntaxKind.TemplateTail);
+}
+/** 개행만 남기고 나머지 문자는 공백으로 — 라인 번호를 보존한다. */
+function blankKeepLines(text) {
+    return text.replace(/[^\n]/g, ' ');
+}
+/**
+ * 문자열/템플릿 토큰의 **내용**만 비우고 구분자(따옴표·백틱·`${`·`}`)는 남긴다.
+ * `'jwt'` → `'   '` · `''` → `''`. 프로퍼티 키·구분자에 걸린 탐지기(예: 라우트
+ * `.post('...')` 의 여는 따옴표)는 여전히 매칭되지만, 문자열 내용이 키를 위장하는
+ * 오탐은 막는다. 개행은 보존한다.
+ */
+function blankStringContent(text) {
+    if (text.length <= 2)
+        return text;
+    return text[0] + blankKeepLines(text.slice(1, -1)) + text[text.length - 1];
+}
+function scanTransform(source, strings) {
+    // skipTrivia=false 로 주석·공백까지 토큰으로 받아 원문을 무손실 재구성한다.
+    const scanner = ts.createScanner(ts.ScriptTarget.Latest, 
+    /* skipTrivia */ false, ts.LanguageVariant.Standard, source);
+    let out = '';
+    for (let token = scanner.scan(); token !== ts.SyntaxKind.EndOfFileToken; token = scanner.scan()) {
+        const text = scanner.getTokenText();
+        if (isCommentKind(token))
+            out += blankKeepLines(text);
+        else if (strings && isStringKind(token))
+            out += blankStringContent(text);
+        else
+            out += text;
+    }
+    return out;
+}
+/**
+ * 주석을 지운 소스를 돌려준다(문자열·코드는 보존 · 라인 번호 유지).
+ * 문자열 **내용**을 봐야 하는 탐지기(예: `strategy: 'jwt'` · import 경로)에 쓴다.
+ */
+export function stripComments(source) {
+    return scanTransform(source, /* strings */ false);
+}
+/**
+ * 주석 + 문자열/템플릿 리터럴 내용을 지운 소스를 돌려준다(구분자·라인 보존).
+ * 프로퍼티 키·키워드만 보는 탐지기(예: `session:` · `auth:` · `rateLimit: false`)에
+ * 쓴다 — 주석도 문자열도 키를 위장하지 못한다.
+ */
+export function stripCommentsAndStrings(source) {
+    return scanTransform(source, /* strings */ true);
+}