@gaonjs/cli 0.33.0 → 0.34.0

package/dist/commands/check.d.ts

@@ -4,7 +4,16 @@ export interface CheckCommandOptions {
     readonly json?: boolean;
     /** 지정 시 그 검사 하나만 실행. 나머지는 스킵. */
     readonly only?: CheckStep;
-    /** true 면 doctor 도 포함. 기본 false. */
+    /**
+     * 결정 157: doctor 는 이제 **기본 포함**이다(CI 가 check 하나만 돌려도 규칙 5 등
+     * doctor 규칙 위반을 잡는다). `noDoctor:true`(CLI `--no-doctor`)로 순수 typecheck/
+     * vue-tsc/build 만 돌린다.
+     */
+    readonly noDoctor?: boolean;
+    /**
+     * @deprecated 결정 157: doctor 가 기본이 돼 의미 없음(무시). `--include-doctor` 는
+     * 하위 호환 no-op — doctor 를 빼려면 `noDoctor`/`--no-doctor` 를 쓴다.
+     */
     readonly includeDoctor?: boolean;
 }
 export type CheckStepStatus = 'passed' | 'failed' | 'skipped';

package/dist/commands/check.js

@@ -7,16 +7,16 @@
  * (`node_modules/.bin/tsc --noEmit` · `node_modules/.bin/vue-tsc --noEmit`
  * · `pnpm -r build` → `npm run build`).
  *
- * The One Way — 하나의 명령이 3(선택 4) 검사를 순서대로 돌린다:
+ * The One Way — 하나의 명령이 4 검사를 순서대로 돌린다(결정 157 · doctor 기본 포함):
  *   1) typecheck (pnpm typecheck 또는 tsc --noEmit)
  *   2) vue-tsc   (pnpm vue-tsc 또는 vue-tsc --noEmit)
  *   3) build     (pnpm build)
- *   (4) doctor   (--include-doctor 시 · 코어 재사용)
+ *   4) doctor    (기본 포함 · 규칙 5 등 doctor 규칙 · --no-doctor 로 뺌 · 코어 재사용)
  *
  * 옵션 최소:
  *   --json                     자동화 · 각 검사의 passed/failed/skipped
  *   --only <name>              단일 검사만
- *   --include-doctor           check 안에서 doctor 도 · 기본 off
+ *   --no-doctor                doctor 를 빼고 typecheck/vue-tsc/build 만 (결정 157)
  *
  * exit code: 검사가 하나라도 실패하면 1, 그 외 0. 미리 검사할 대상이
  * 하나도 없으면(예: 스크립트도 없고 바이너리도 없음) 스킵으로 리포트 —
@@ -34,6 +34,7 @@ import { runDoctorCommand } from '../doctor.js';
 import { regenerateGaonOnce, resolveDevLayout } from '../dev.js';
 import { registerTsResolve } from '../tsResolve.js';
 import { listFrontendApps, verifyAppDist } from '../dev/build.js';
+import { generateMessagesDts } from '../messages-gen.js';
 /**
  * 프로젝트 스크립트 존재 여부. pnpm/npm 어느 쪽이든 `scripts.<name>` 을
  * 정의해 두면 우선 사용한다.
@@ -233,7 +234,7 @@ async function runDoctorStep(cwd) {
  */
 async function regenerateGaon(cwd) {
     const layout = resolveDevLayout(cwd);
-    if (!layout.schemaDir && layout.apps.length === 0) {
+    if (!layout.schemaDir && layout.apps.length === 0 && !layout.localesDir) {
         return { status: 'skipped', tables: false, apps: [] };
     }
     // 생성기는 사용자 스키마·컨트롤러 .ts 를 동적 import 한다. TS-for-ESM
@@ -244,6 +245,7 @@ async function regenerateGaon(cwd) {
         const result = await regenerateGaonOnce(layout, {
             regenerateTables: generateTablesDts,
             regenerateRoutes: generateRoutesDts,
+            regenerateMessages: generateMessagesDts,
         });
         return { status: 'done', tables: result.tables, apps: result.apps };
     }
@@ -269,7 +271,9 @@ export async function runCheckCommand(opts = {}) {
     const cwd = opts.cwd ?? process.cwd();
     const json = opts.json ?? false;
     const only = opts.only;
-    const includeDoctor = opts.includeDoctor ?? false;
+    // 결정 157: doctor 는 기본 포함(규칙 5 등 doctor 규칙이 check 만 도는 CI 에서 새지 않게).
+    // --no-doctor 로만 뺀다. --include-doctor(구)는 이제 no-op(기본이 된 동작).
+    const runDoctor = !opts.noDoctor;
     // 규칙 3 — 검사는 최신 타입 브리지 위에서만 신뢰할 수 있다. 재생성이
     // 실패하면 stale .gaon 으로 검사하지 않고 즉시 중단한다.
     const regen = await regenerateGaon(cwd);
@@ -277,7 +281,7 @@ export async function runCheckCommand(opts = {}) {
         ? []
         : only
             ? [only]
-            : ['typecheck', 'vue-tsc', 'build', ...(includeDoctor ? ['doctor'] : [])];
+            : ['typecheck', 'vue-tsc', 'build', ...(runDoctor ? ['doctor'] : [])];
     const results = [];
     for (const step of steps) {
         if (step === 'doctor') {

package/dist/commands/dev.js

@@ -26,6 +26,7 @@ import { registerTsResolve } from '../tsResolve.js';
 import { startDev, resolveDevLayout } from '../dev.js';
 import { generateTablesDts, watchDir } from '@gaonjs/data';
 import { generateRoutesDts } from '@gaonjs/web';
+import { generateMessagesDts } from '../messages-gen.js';
 import { createDevConsole } from '../dev/console.js';
 import { ensureInfra, composeDown } from '../dev/docker.js';
 import { startTscWatchers, killChild } from '../dev/tsc.js';
@@ -86,6 +87,7 @@ async function startGaonRegen(args) {
         layout,
         regenerateTables: generateTablesDts,
         regenerateRoutes: generateRoutesDts,
+        regenerateMessages: generateMessagesDts,
         watch: watchDir,
         log: (e) => {
             if (e.kind === 'ready') {

package/dist/commands/gen.js

@@ -15,6 +15,7 @@
  */
 import { generateTablesDts } from '@gaonjs/data';
 import { generateRoutesDts } from '@gaonjs/web';
+import { generateMessagesDts } from '../messages-gen.js';
 import { regenerateGaonOnce, resolveDevLayout } from '../dev.js';
 import { registerTsResolve } from '../tsResolve.js';
 /**
@@ -24,13 +25,14 @@ import { registerTsResolve } from '../tsResolve.js';
  */
 export async function regenerateProjectGaon(cwd) {
     const layout = resolveDevLayout(cwd);
-    if (!layout.schemaDir && layout.apps.length === 0) {
-        return { tables: false, apps: [], skipped: true };
+    if (!layout.schemaDir && layout.apps.length === 0 && !layout.localesDir) {
+        return { tables: false, apps: [], messages: false, skipped: true };
     }
     registerTsResolve();
     const result = await regenerateGaonOnce(layout, {
         regenerateTables: generateTablesDts,
         regenerateRoutes: generateRoutesDts,
+        regenerateMessages: generateMessagesDts,
     });
     return { ...result, skipped: false };
 }

package/dist/db/projectData.d.ts

@@ -0,0 +1,14 @@
+import type { ConnectionConfig } from '@gaonjs/data';
+/** 프로젝트(projDir) 관점에서 @gaonjs/data 가 해상되는 경로. 미설치면 null. */
+export declare function resolveProjectDataPath(projDir: string): string | null;
+/** 프로젝트 @gaonjs/data 가 CLI 것과 **다른 인스턴스**인가(전역 설치 이중 로드 신호). */
+export declare function isSplitDataInstance(projDir: string): boolean;
+/**
+ * 프로젝트의 @gaonjs/data 인스턴스가 CLI 것과 다르면(전역 설치) 그 인스턴스에 커넥션을
+ * 등록해 모델 레이어가 같은 레지스트리를 보게 한다. 같은 인스턴스(로컬)면 resolveDbTarget
+ * 이 이미 등록했으므로 **no-op(null 반환)** — 로컬 경로 무회귀. 반환 핸들의 close() 는
+ * 프로젝트 인스턴스 커넥션을 정리한다(다른 인스턴스일 때만).
+ */
+export declare function registerInProjectData(projDir: string, dbKey: string, connCfg: ConnectionConfig): Promise<{
+    close(): Promise<void>;
+} | null>;

package/dist/db/projectData.js

@@ -0,0 +1,51 @@
+// @gaonjs/cli · 프로젝트 로컬 @gaonjs/data 해상 (결정 156 · 전역-로컬 레지스트리 분열 근본 수정)
+//
+// 전역 설치 CLI(`npm i -g gaonjs`)는 자기 번들의 @gaonjs/data 를 로드하고, 프로젝트의
+// domain 코드(seed 가 실행하는 모델)는 **프로젝트 node_modules** 의 @gaonjs/data 를
+// 로드한다(tsResolve 훅이 bare 지정자를 안 건드림 · dual package hazard). 두 인스턴스는
+// 커넥션 레지스트리가 갈려, resolveDbTarget 이 CLI 인스턴스에 등록한 커넥션을 모델
+// 레이어(프로젝트 인스턴스)가 못 봐서 seed 가 "커넥션 'main' 미등록" 으로 죽었다.
+// db migrate/diff/status 는 모델을 안 거쳐 이 분열을 가렸다(13차 실측).
+//
+// 근본 수정: seed 처럼 **프로젝트 모델 레이어를 거치는** 명령은, 프로젝트 인스턴스의
+// @gaonjs/data 에도 커넥션을 등록해 모델과 **단일 레지스트리**를 공유한다. 로컬 설치
+// (CLI·프로젝트가 같은 @gaonjs/data)면 두 경로가 같은 모듈이라 no-op — migrate/diff/
+// status 를 비롯한 로컬 경로는 무회귀다.
+import { createRequire } from 'node:module';
+import { pathToFileURL } from 'node:url';
+import { join, resolve as resolvePath } from 'node:path';
+/** CLI 자신이 로드한 @gaonjs/data 의 해상 경로. */
+function cliDataPath() {
+    return createRequire(import.meta.url).resolve('@gaonjs/data');
+}
+/** 프로젝트(projDir) 관점에서 @gaonjs/data 가 해상되는 경로. 미설치면 null. */
+export function resolveProjectDataPath(projDir) {
+    try {
+        // projDir/package.json 기준으로 해상 — 프로젝트 node_modules 의 @gaonjs/data.
+        const req = createRequire(join(resolvePath(projDir), 'package.json'));
+        return req.resolve('@gaonjs/data');
+    }
+    catch {
+        return null;
+    }
+}
+/** 프로젝트 @gaonjs/data 가 CLI 것과 **다른 인스턴스**인가(전역 설치 이중 로드 신호). */
+export function isSplitDataInstance(projDir) {
+    const projPath = resolveProjectDataPath(projDir);
+    return projPath !== null && projPath !== cliDataPath();
+}
+/**
+ * 프로젝트의 @gaonjs/data 인스턴스가 CLI 것과 다르면(전역 설치) 그 인스턴스에 커넥션을
+ * 등록해 모델 레이어가 같은 레지스트리를 보게 한다. 같은 인스턴스(로컬)면 resolveDbTarget
+ * 이 이미 등록했으므로 **no-op(null 반환)** — 로컬 경로 무회귀. 반환 핸들의 close() 는
+ * 프로젝트 인스턴스 커넥션을 정리한다(다른 인스턴스일 때만).
+ */
+export async function registerInProjectData(projDir, dbKey, connCfg) {
+    const projPath = resolveProjectDataPath(projDir);
+    if (!projPath || projPath === cliDataPath())
+        return null; // 로컬 설치 = 단일 인스턴스 · no-op
+    const mod = (await import(pathToFileURL(projPath).href));
+    const db = mod.createDb(connCfg);
+    mod.registerConnection(dbKey, db, connCfg.adapter);
+    return { close: () => mod.destroyAllConnections() };
+}

package/dist/db.js

@@ -12,6 +12,7 @@ import { pathToFileURL } from 'node:url';
 import { createDb, registerConnection, destroyAllConnections, isSeedDef, } from '@gaonjs/data';
 import { registerTsResolve } from './tsResolve.js';
 import { resolveDbTarget } from './db/resolve.js';
+import { registerInProjectData, isSplitDataInstance } from './db/projectData.js';
 /** DB URL 에서 어댑터를 추정한다(gaon work 와 동일 규칙). */
 function dbConfigFromUrl(url) {
     if (url.startsWith('mysql://') || url.startsWith('mariadb://')) {
@@ -52,24 +53,59 @@ export async function runDbSeedCommand(opts = {}) {
     if (opts.databaseUrl) {
         const cfg = dbConfigFromUrl(opts.databaseUrl);
         registerConnection(dbKey, createDb(cfg), cfg.adapter);
+        // 결정 156: 전역 설치면 프로젝트 인스턴스에도 등록(모델과 단일 레지스트리 공유).
+        const projData = await registerInProjectData(root, dbKey, cfg);
         try {
             const def = await loadSeed(root);
-            await def.run();
+            await runSeed(def, root);
             return { exitCode: 0, ...SEED_OK };
         }
         finally {
+            if (projData)
+                await projData.close();
             await destroyAllConnections();
         }
     }
     // 그 외 — migrate 와 같은 해석 경로: gaon.config.ts db.<키> → GAON_DATABASE_URL.
     // config 도 env 도 없으면 resolveDbTarget 이 수리 안내 에러를 던진다(§7.5.3).
     const target = await resolveDbTarget({ cwd: root, dbKey, configPath: opts.configPath });
+    // 결정 156: seed 는 모델 레이어를 거친다 — 전역 설치(CLI≠프로젝트 @gaonjs/data)면
+    // 프로젝트 인스턴스에도 커넥션을 등록해 "main 미등록" 분열을 근본에서 없앤다. 로컬
+    // 설치(단일 인스턴스)면 no-op. url 없는 config 는 seed 대상이 아니라 안내한다.
+    if (!target.url) {
+        await target.close();
+        throw new Error(`[gaon db seed] 커넥션 '${dbKey}' 에 url 이 없어 시드를 실행할 수 없습니다.\n` +
+            `  → gaon.config.ts 의 db.${dbKey} 에 url 을 두거나 .env 의 GAON_DATABASE_URL 을 설정하세요.`);
+    }
+    const projData = await registerInProjectData(root, dbKey, { adapter: target.adapter, url: target.url, poolMax: 1 });
     try {
         const def = await loadSeed(root);
-        await def.run();
+        await runSeed(def, root);
         return { exitCode: 0, ...SEED_OK };
     }
     finally {
+        if (projData)
+            await projData.close();
         await target.close();
     }
 }
+/**
+ * 시드를 실행하되, "커넥션 미등록" 계열 실패는 전역-로컬 @gaonjs/data 분열로 진단해
+ * 실제 수리(로컬 실행)로 안내한다(결정 156 · §7.5.3 — 이미 등록된 커넥션을 또 선언하라던
+ * 오진 제거).
+ */
+async function runSeed(def, root) {
+    try {
+        await def.run();
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        if (/등록되지 않았|not registered|미등록/.test(msg) && isSplitDataInstance(root)) {
+            throw new Error(`[gaon db seed] 시드 실행 중 커넥션을 찾지 못했습니다 — 전역 설치 CLI 와 프로젝트가\n` +
+                `@gaonjs/data 를 각각 로드해 커넥션 레지스트리가 갈렸습니다(dual package hazard).\n` +
+                `  → 프로젝트 로컬로 실행하세요: npx gaon db seed (또는 package.json 스크립트로 실행)\n` +
+                `  (원본: ${msg})`);
+        }
+        throw err;
+    }
+}

package/dist/dev.d.ts

@@ -11,11 +11,17 @@ export interface DevLayout {
     /** .gaon/tables.d.ts */
     readonly tablesOut: string;
     readonly apps: readonly DevApp[];
+    /** locales/ (없으면 undefined — messages 축 생략 · 결정 158 · W2). */
+    readonly localesDir?: string;
+    /** .gaon/messages.d.ts */
+    readonly messagesOut: string;
 }
 export interface DevDeps {
     readonly layout: DevLayout;
     regenerateTables(schemaDir: string, out: string): Promise<unknown>;
     regenerateRoutes(appDir: string, out: string): Promise<unknown>;
+    /** locales/ → .gaon/messages.d.ts (결정 158 · W2). i18n 축을 쓰는 호출자만 준다. */
+    regenerateMessages?(localesDir: string, out: string): unknown;
     watch(dir: string, opts: WatchOptions): WatchHandle;
     log(event: DevEvent): void;
     onError(err: Error): void;
@@ -26,7 +32,7 @@ export type DevEvent = {
     readonly apps: string[];
 } | {
     readonly kind: 'regen';
-    readonly target: 'tables' | 'routes';
+    readonly target: 'tables' | 'routes' | 'messages';
     readonly app?: string;
 } | {
     readonly kind: 'stopped';
@@ -44,12 +50,16 @@ export declare function startDev(deps: DevDeps): Promise<DevHandle>;
 export interface RegenDeps {
     regenerateTables(schemaDir: string, out: string): Promise<unknown>;
     regenerateRoutes(appDir: string, out: string): Promise<unknown>;
+    /** locales/ → .gaon/messages.d.ts (결정 158 · W2). i18n 축을 쓰는 호출자만 준다. */
+    regenerateMessages?(localesDir: string, out: string): unknown;
 }
 export interface RegenResult {
     /** tables.d.ts 를 재생성했는가(domain/schema 존재 시에만). */
     readonly tables: boolean;
     /** routes.d.ts 를 재생성한 앱 이름. */
     readonly apps: readonly string[];
+    /** messages.d.ts 를 재생성했는가(locales/ 존재 · 결정 158 · W2). */
+    readonly messages: boolean;
 }
 /**
  * 워처 없이 .gaon 타입 브리지를 1회 전체 재생성한다. `gaon check` 처럼

package/dist/dev.js

@@ -13,6 +13,8 @@
  */
 import { readdirSync, existsSync } from 'node:fs';
 import { join, resolve } from 'node:path';
+/** locales/*.json 변경(메시지 카탈로그) — messages.d.ts 재생성 트리거. */
+const isMessagesChange = (f) => !f.includes('.gaon') && f.endsWith('.json');
 const isSchemaChange = (f) => f.endsWith('.ts') && !f.endsWith('.d.ts') && !f.endsWith('.test.ts') && !f.includes('.gaon');
 const isRoutesChange = (f) => !f.includes('.gaon') &&
     f.endsWith('.ts') &&
@@ -35,6 +37,11 @@ export async function startDev(deps) {
         await deps.regenerateRoutes(app.appDir, app.routesOut);
         deps.log({ kind: 'regen', target: 'routes', app: app.name });
     }
+    // 결정 158(W2): locales/ → messages.d.ts.
+    if (layout.localesDir && deps.regenerateMessages) {
+        await deps.regenerateMessages(layout.localesDir, layout.messagesOut);
+        deps.log({ kind: 'regen', target: 'messages' });
+    }
     // 2) 스키마 워치 → tables.d.ts 재생성.
     if (layout.schemaDir) {
         const schemaDir = layout.schemaDir;
@@ -58,6 +65,19 @@ export async function startDev(deps) {
             onError: deps.onError,
         }));
     }
+    // 4) locales 워치 → messages.d.ts 재생성(결정 158 · W2).
+    if (layout.localesDir && deps.regenerateMessages) {
+        const localesDir = layout.localesDir;
+        const regenerateMessages = deps.regenerateMessages;
+        handles.push(deps.watch(localesDir, {
+            filter: isMessagesChange,
+            onChange: async () => {
+                await regenerateMessages(localesDir, layout.messagesOut);
+                deps.log({ kind: 'regen', target: 'messages' });
+            },
+            onError: deps.onError,
+        }));
+    }
     deps.log({ kind: 'ready', schema: !!layout.schemaDir, apps: layout.apps.map((a) => a.name) });
     return {
         close() {
@@ -80,7 +100,12 @@ export async function regenerateGaonOnce(layout, deps) {
     for (const app of layout.apps) {
         await deps.regenerateRoutes(app.appDir, app.routesOut);
     }
-    return { tables: !!layout.schemaDir, apps: layout.apps.map((a) => a.name) };
+    // 결정 158(W2): locales/ 가 있으면 messages.d.ts 도 재생성한다(i18n 키 타입 브리지).
+    let messages = false;
+    if (layout.localesDir && deps.regenerateMessages) {
+        messages = (await deps.regenerateMessages(layout.localesDir, layout.messagesOut)) === true;
+    }
+    return { tables: !!layout.schemaDir, apps: layout.apps.map((a) => a.name), messages };
 }
 /** cwd 관례로 프로젝트 레이아웃을 해석한다(존재하는 것만 포함). */
 export function resolveDevLayout(cwd) {
@@ -102,10 +127,13 @@ export function resolveDevLayout(cwd) {
             });
         }
     }
+    const localesDirPath = join(root, 'locales');
     return {
         schemaDir: existsSync(schemaDirPath) ? schemaDirPath : undefined,
         tablesOut: join(root, '.gaon', 'tables.d.ts'),
         apps: apps.sort((a, b) => a.name.localeCompare(b.name)),
+        localesDir: existsSync(localesDirPath) ? localesDirPath : undefined,
+        messagesOut: join(root, '.gaon', 'messages.d.ts'),
     };
 }
 // runDevCommand · DevCommandOptions 는 M9-C 에서 commands/dev.ts 로 이동.

package/dist/generate.d.ts

@@ -1,6 +1,12 @@
 export interface AuthScaffoldOptions {
     /** 대상 앱(apps/<app>). 기본 'web'. */
     readonly app?: string;
+    /**
+     * 결정 155: 공개 회원가입(registration)을 깔지 여부. 기본은 **앱명 기반 시큐어**
+     * — web 은 공개 가입 O, 비-web(admin 등)은 공개 가입 X + 역할 게이트(authorize).
+     * `--public` 로 비-web 앱도 공개 가입을 opt-in 한다(공개 비-web 앱용 탈출구).
+     */
+    readonly public?: boolean;
 }
 /** 생성할 파일 하나 — 경로는 프로젝트 루트 기준. */
 export interface ScaffoldFile {
@@ -14,13 +20,14 @@ export interface ScaffoldResult {
     /** 손 수리가 필요한 지점 — 수리 안내 문장(§7.5.3)을 그대로 담는다. */
     readonly warnings: string[];
 }
-/** 인증 스캐폴드가 생성하는 파일 목록(라우트 제외). 템플릿을 읽어 렌더링한다. */
+/** 인증 스캐폴드가 생성하는 파일 목록(라우트 제외). 템플릿을 읽어 렌더링한다.
+ *  결정 155: 공개 가입 여부(includePublic)로 registration·Signup·dashboard 변형을 가른다. */
 export declare function authScaffoldFiles(opts?: AuthScaffoldOptions): ScaffoldFile[];
 /**
  * 기존 routes.ts 에 세션·회원가입 리소스를 끼워 넣는다. 이미 있으면 null.
  * `routes((r) => {` 콜백 여는 지점 뒤에 두 줄을 삽입한다.
  */
-export declare function patchRoutes(existing: string): string | null;
+export declare function patchRoutes(existing: string, includePublic?: boolean): string | null;
 /**
  * 기존 app.config.ts 에 auth 배선을 끼워 넣는다 (결정 93 · gaon new 기본 web 앱은
  * 세션만 배선돼 있어 g auth 는 auth 만 추가하면 완성된다). 반환:
@@ -35,6 +42,8 @@ export interface GenerateAuthOptions {
     readonly cwd?: string;
     readonly app?: string;
     readonly json?: boolean;
+    /** 결정 155: 비-web 앱도 공개 회원가입을 opt-in(공개 비-web 앱용 탈출구). */
+    readonly public?: boolean;
 }
 /** `gaon g auth` 진입점. 스캐폴드를 쓰고 결과를 사람/JSON 으로 출력한다. */
 export declare function runGenerateAuthCommand(opts?: GenerateAuthOptions): number;

package/dist/generate.js

@@ -16,6 +16,11 @@ import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
 import { dirname, join, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { authUiKitFiles, writeUiKitFiles } from './uikit.js';
+/** 결정 155: 이 스캐폴드가 공개 회원가입을 포함하는가(web 기본 O · 비-web 은 --public 시만). */
+function includesPublicRegistration(opts) {
+    const app = opts.app ?? 'web';
+    return app === 'web' || opts.public === true;
+}
 // ── 템플릿 로드·치환 ───────────────────────────────────────────
 // 템플릿은 이 모듈과 같은 위치의 templates/auth/ 에 있다(빌드가 dist 로 복사).
 const TEMPLATE_DIR = join(dirname(fileURLToPath(import.meta.url)), 'templates', 'auth');
@@ -42,46 +47,59 @@ function sessionSecretEnvFor(app) {
 function devSessionSecretFor(app) {
     return `dev-only-session-secret-${app}-change-me-now!!`;
 }
-/** 템플릿 파일을 읽어 토큰을 치환한다. {{APP_NAME}}·{{URL_PREFIX}}·
- *  {{SESSION_SECRET_ENV}} 는 Vue 의 {{ }} 보간과 겹치지 않는 고정 리터럴이라
- *  단순 replaceAll 로 안전하다(결정 141). */
-function renderTemplate(name, app) {
+/** 결정 155: Login 페이지의 회원가입 링크 — 공개 가입 앱에만 넣는다(시큐어 앱은 뺀다).
+ *  템플릿의 `{{SIGNUP_LINK}}` 자리(8칸 들여쓰기)에 in-place 치환되므로 첫 줄은 들여쓰기 없이. */
+function signupLinkMarkup(app) {
+    return (`<p class="mt-4 text-center text-sm text-muted-foreground">\n` +
+        `          계정이 없으신가요?\n` +
+        `          <Link href="${urlPrefixFor(app)}/registration/new" class="font-medium text-primary underline-offset-4 hover:underline">회원가입</Link>\n` +
+        `        </p>`);
+}
+/** 템플릿 파일을 읽어 토큰을 치환한다. {{APP_NAME}}·{{URL_PREFIX}}·{{SESSION_SECRET_ENV}}·
+ *  {{SIGNUP_LINK}} 는 Vue 의 {{ }} 보간과 겹치지 않는 고정 리터럴이라 단순 replaceAll 로
+ *  안전하다(결정 141·155). SIGNUP_LINK 는 공개 가입 앱에만 링크를, 시큐어 앱엔 빈 값. */
+function renderTemplate(name, app, includePublic) {
     const raw = readFileSync(join(TEMPLATE_DIR, name), 'utf8');
     return raw
         .replaceAll('{{APP_NAME}}', app)
         .replaceAll('{{URL_PREFIX}}', urlPrefixFor(app))
-        .replaceAll('{{SESSION_SECRET_ENV}}', sessionSecretEnvFor(app));
+        .replaceAll('{{SESSION_SECRET_ENV}}', sessionSecretEnvFor(app))
+        .replaceAll('{{SIGNUP_LINK}}', includePublic ? signupLinkMarkup(app) : '');
 }
-/** 템플릿 파일 → 생성 경로 매핑(라우트 제외 — 라우트는 패치로 처리). */
-const TEMPLATES = [
-    { tpl: 'user.schema.ts.tpl', out: () => 'domain/schema/users.ts' },
-    { tpl: 'user.model.ts.tpl', out: () => 'domain/models/User.ts' },
-    { tpl: 'auth.wiring.ts.tpl', out: (a) => `apps/${a}/auth.ts` },
-    { tpl: 'session.controller.ts.tpl', out: (a) => `apps/${a}/controllers/session.ts` },
-    { tpl: 'registration.controller.ts.tpl', out: (a) => `apps/${a}/controllers/registration.ts` },
-    { tpl: 'dashboard.controller.ts.tpl', out: (a) => `apps/${a}/controllers/dashboard.ts` },
-    // 결정 32·46: Vue 페이지 경로 세그먼트는 PascalCase(Route 이름) — 'Auth/'.
-    // examples/blog 정본과 page-filename doctor 규칙에 정합(소문자 'auth/' 는
-    // doctor 가 error 로 잡던 스캐폴드 표류였다 · W10 실측).
-    { tpl: 'Login.vue.tpl', out: (a) => `apps/${a}/pages/Auth/Login.vue` },
-    { tpl: 'Signup.vue.tpl', out: (a) => `apps/${a}/pages/Auth/Signup.vue` },
-    { tpl: 'Dashboard.vue.tpl', out: (a) => `apps/${a}/pages/Dashboard.vue` },
-    // 결정 59: 세션·인증 배선은 app.config.ts — 표준 부팅(gaon dev/serve = wireGaon)이
-    // 소비한다. 과거의 수동 부팅 스캐폴드(app.ts·server.ts)는 두 번째 부팅 경로를
-    // 만들어 One Way 를 깨고, 표준 경로에는 auth 배선이 빠져 currentUser 가 영구
-    // null 이 되는 파손을 남겼다 — 제거했다.
-    { tpl: 'app.config.ts.tpl', out: (a) => `apps/${a}/app.config.ts` },
-];
-/** 인증 스캐폴드가 생성하는 파일 목록(라우트 제외). 템플릿을 읽어 렌더링한다. */
+/** 인증 스캐폴드가 생성하는 파일 목록(라우트 제외). 템플릿을 읽어 렌더링한다.
+ *  결정 155: 공개 가입 여부(includePublic)로 registration·Signup·dashboard 변형을 가른다. */
 export function authScaffoldFiles(opts = {}) {
     const app = opts.app ?? 'web';
-    return TEMPLATES.map(({ tpl, out }) => ({ path: out(app), contents: renderTemplate(tpl, app) }));
+    const includePublic = includesPublicRegistration(opts);
+    const specs = [
+        { tpl: 'user.schema.ts.tpl', out: 'domain/schema/users.ts' },
+        { tpl: 'user.model.ts.tpl', out: 'domain/models/User.ts' },
+        { tpl: 'auth.wiring.ts.tpl', out: `apps/${app}/auth.ts` },
+        { tpl: 'session.controller.ts.tpl', out: `apps/${app}/controllers/session.ts` },
+        // 결정 155: 시큐어(비-web · 비-public) 앱은 역할 게이트 대시보드, 공개 앱은 requireAuth 대시보드.
+        {
+            tpl: includePublic ? 'dashboard.controller.ts.tpl' : 'dashboard.secure.controller.ts.tpl',
+            out: `apps/${app}/controllers/dashboard.ts`,
+        },
+        // 결정 32·46: Vue 페이지 경로 세그먼트는 PascalCase(Route 이름) — 'Auth/'.
+        { tpl: 'Login.vue.tpl', out: `apps/${app}/pages/Auth/Login.vue` },
+        { tpl: 'Dashboard.vue.tpl', out: `apps/${app}/pages/Dashboard.vue` },
+        // 결정 59: 세션·인증 배선은 app.config.ts — 표준 부팅(gaon dev/serve = wireGaon)이 소비한다.
+        { tpl: 'app.config.ts.tpl', out: `apps/${app}/app.config.ts` },
+    ];
+    // 결정 155: 공개 가입 앱만 회원가입 컨트롤러·페이지를 깐다. 시큐어 앱(admin 등)은 빼서
+    // "관리 앱에 공개 가입 + 로그인 고객 200" 위험 기본을 구조적으로 차단한다.
+    if (includePublic) {
+        specs.splice(4, 0, { tpl: 'registration.controller.ts.tpl', out: `apps/${app}/controllers/registration.ts` });
+        specs.push({ tpl: 'Signup.vue.tpl', out: `apps/${app}/pages/Auth/Signup.vue` });
+    }
+    return specs.map(({ tpl, out }) => ({ path: out, contents: renderTemplate(tpl, app, includePublic) }));
 }
 /**
  * 기존 routes.ts 에 세션·회원가입 리소스를 끼워 넣는다. 이미 있으면 null.
  * `routes((r) => {` 콜백 여는 지점 뒤에 두 줄을 삽입한다.
  */
-export function patchRoutes(existing) {
+export function patchRoutes(existing, includePublic = true) {
     if (existing.includes("resource('session')"))
         return null;
     const m = existing.match(/routes\(\s*\(\s*\w+\s*\)\s*=>\s*\{/);
@@ -91,9 +109,10 @@ export function patchRoutes(existing) {
     // dashboard 라우트도 함께 배선한다 — 없으면 스캐폴드 Dashboard.vue 의
     // pageProps<'…:dashboard#show'> 가 라우트 맵에서 해상되지 않아 vue-tsc 가
     // 깨진다(결정 60 클린룸 실측 — gaon new 프로젝트에 g auth 를 얹는 경로).
+    // 결정 155: 회원가입 리소스는 공개 가입 앱에만(시큐어 앱은 빼서 공개 가입 라우트 자체를 안 깐다).
     const inject = "\n  r.get('/dashboard', 'dashboard#show') // 보호 페이지 (gaon g auth)" +
         "\n  r.resource('session') // 로그인/로그아웃 (gaon g auth)" +
-        "\n  r.resource('registration') // 회원가입 (gaon g auth)";
+        (includePublic ? "\n  r.resource('registration') // 회원가입 (gaon g auth)" : '');
     return existing.slice(0, insertAt) + inject + existing.slice(insertAt);
 }
 /**
@@ -152,6 +171,7 @@ export function writeAuthScaffold(cwd, opts = {}) {
     // 필요한 최소 세트를 먼저 보장한다 — 이미 있으면(gaon g ui-kit 를 먼저 돌린
     // 경우) skip, 없으면 생성. 이 보장이 없으면 스캐폴드 직후 페이지가 컴포넌트를
     // 해상하지 못해 vue-tsc 가 깨진다(gaon new → g auth 단독 경로 · 결정 60 게이트).
+    const includePublic = includesPublicRegistration(opts);
     const ui = writeUiKitFiles(root, authUiKitFiles(app));
     created.push(...ui.created);
     skipped.push(...ui.skipped);
@@ -194,7 +214,7 @@ export function writeAuthScaffold(cwd, opts = {}) {
     const routesPath = join(root, 'apps', app, 'routes.ts');
     const routesRel = `apps/${app}/routes.ts`;
     if (existsSync(routesPath)) {
-        const patchedContent = patchRoutes(readFileSync(routesPath, 'utf8'));
+        const patchedContent = patchRoutes(readFileSync(routesPath, 'utf8'), includePublic);
         if (patchedContent) {
             writeFileSync(routesPath, patchedContent, 'utf8');
             patched.push(routesRel);
@@ -205,18 +225,27 @@ export function writeAuthScaffold(cwd, opts = {}) {
     }
     else {
         mkdirSync(dirname(routesPath), { recursive: true });
-        writeFileSync(routesPath, renderTemplate('routes.ts.tpl', app), 'utf8');
+        writeFileSync(routesPath, renderTemplate('routes.ts.tpl', app, includePublic), 'utf8');
         created.push(routesRel);
     }
+    // 결정 155: 시큐어 앱(공개 가입 미생성)은 역할 게이트 대시보드를 깔았다 — role 컬럼을
+    // 두라고 안내한다(§7.5.3 · authorize 예시가 실제 역할 규칙이 되도록).
+    if (!includePublic) {
+        warnings.push(`apps/${app}/ 는 시큐어 스캐폴드입니다(공개 회원가입 미생성 · 결정 155).\n` +
+            `→ 관리자는 직접 만들거나 승격하세요(공개 가입 라우트 없음). 공개 가입이 필요하면 --public 로 다시 생성.\n` +
+            `→ 역할 인가를 완성하려면 domain/schema/users.ts 에 role 컬럼을 추가하세요:\n` +
+            `   role: t.string().default('user'),\n` +
+            `   그러면 apps/${app}/controllers/dashboard.ts 의 authorize(역할) 게이트가 실제 역할로 동작합니다.`);
+    }
     return { created: created.sort(), skipped: skipped.sort(), patched: patched.sort(), warnings };
 }
 /** `gaon g auth` 진입점. 스캐폴드를 쓰고 결과를 사람/JSON 으로 출력한다. */
 export function runGenerateAuthCommand(opts = {}) {
     const cwd = opts.cwd ?? process.cwd();
     const app = opts.app ?? 'web';
-    const result = writeAuthScaffold(cwd, { app });
+    const result = writeAuthScaffold(cwd, { app, public: opts.public });
     if (opts.json) {
-        process.stdout.write(JSON.stringify({ command: 'g auth', app, ...result }, null, 2) + '\n');
+        process.stdout.write(JSON.stringify({ command: 'g auth', app, public: opts.public ?? app === 'web', ...result }, null, 2) + '\n');
         return 0;
     }
     const lines = [''];

package/dist/index.d.ts

@@ -6,6 +6,7 @@ export { runCheckCommand, type CheckCommandOptions, type CheckStep, type CheckSt
 export { runGenCommand, regenerateProjectGaon, type GenCommandOptions, type GenResult, } from "./commands/gen.js";
 export { runBuildCommand, type BuildCommandOptions, type BuildCommandResult, } from "./commands/build.js";
 export { buildApp, buildAllApps, listFrontendApps, verifyAppDist, appBase, type BuildAppOptions, type DistVerifyResult, } from "./dev/build.js";
+export { generateMessagesDts } from "./messages-gen.js";
 export { runNewCommand, type NewCommandOptions, type NewCommandResult } from "./commands/new.js";
 export { runConsoleCommand, type ConsoleCommandOptions } from "./commands/console.js";
 export { runTestCommand, type TestCommandOptions, type TestScope } from "./commands/test.js";

package/dist/index.js

@@ -35,6 +35,7 @@ export { runCheckCommand, } from "./commands/check.js";
 export { runGenCommand, regenerateProjectGaon, } from "./commands/gen.js";
 export { runBuildCommand, } from "./commands/build.js";
 export { buildApp, buildAllApps, listFrontendApps, verifyAppDist, appBase, } from "./dev/build.js";
+export { generateMessagesDts } from "./messages-gen.js";
 export { runNewCommand } from "./commands/new.js";
 export { runConsoleCommand } from "./commands/console.js";
 export { runTestCommand } from "./commands/test.js";
@@ -103,7 +104,7 @@ function renderHelp(version = VERSION) {
         "    gaon serve         웹 서버 부팅 (gaon.config.ts 자동 배선 · Fastify listen)",
         "    gaon serve --port <n> --host <h>   리슨 포트·호스트 (config 값을 덮음)",
         "    gaon serve --workers <n|auto>      node:cluster 워커 다중화 (env WEB_CONCURRENCY · 기본 1)",
-        "    gaon check         typecheck · vue-tsc · build 통합 검사 (--only <step> · --include-doctor)",
+        "    gaon check         typecheck · vue-tsc · build · doctor 통합 검사 (--only <step> · --no-doctor)",
         "    gaon gen           .gaon 타입 브리지 + api() 런타임 매니페스트만 재생성 (서버·검사 없이 · build 전제 · --json)",
         "    gaon build         멀티 앱 프론트 프로덕션 빌드 (gaon gen + apps/* 순회 · 앱별 dist/<앱>·base=/<앱>/ · --json)",
         "    gaon console       프로젝트 컨텍스트 REPL (--no-config)",
@@ -224,8 +225,8 @@ export function runCli(argv, opts = {}) {
         return;
     }
     // `gaon check` — typecheck · vue-tsc · build (·doctor) 통합 검사(M9-G).
-    // package.json 스크립트 관례 재사용. --only <step> 로 단일 단계, --include-doctor
-    // 로 doctor 포함. 종료 코드로 결과 전달.
+    // package.json 스크립트 관례 재사용. --only <step> 로 단일 단계. 결정 157: doctor 는
+    // 기본 포함(규칙 5 등이 check 만 도는 CI 에서 새지 않게) · --no-doctor 로만 뺀다.
     if (argv[0] === "check") {
         const knownSteps = ["typecheck", "vue-tsc", "build", "doctor"];
         const onlyIdx = argv.indexOf("--only");
@@ -236,7 +237,7 @@ export function runCli(argv, opts = {}) {
         void runCheckCommand({
             json: argv.includes("--json"),
             only,
-            includeDoctor: argv.includes("--include-doctor"),
+            noDoctor: argv.includes("--no-doctor"),
         })
             .then((code) => {
             process.exitCode = code;
@@ -395,7 +396,8 @@ export function runCli(argv, opts = {}) {
         if (argv[1] === "auth") {
             const appIdx = argv.indexOf("--app");
             const app = appIdx >= 0 ? argv[appIdx + 1] : undefined;
-            const code = runGenerateAuthCommand({ app, json: argv.includes("--json") });
+            // 결정 155: --public 은 비-web 앱도 공개 회원가입을 opt-in(공개 비-web 앱 탈출구).
+            const code = runGenerateAuthCommand({ app, json: argv.includes("--json"), public: argv.includes("--public") });
             process.exitCode = code;
             return;
         }

package/dist/messages-gen.d.ts

@@ -0,0 +1,6 @@
+/**
+ * locales/ 카탈로그에서 .gaon/messages.d.ts 를 생성한다. 카탈로그가 없거나 비어
+ * 있으면 생성하지 않는다(GaonMessages 를 비운 채로 둬 t() 키가 string 폴백 — i18n 을
+ * 안 쓰는 프로젝트가 never 로 깨지지 않게). 생성 여부를 돌려준다.
+ */
+export declare function generateMessagesDts(localesDir: string, out: string): boolean;