@hanmariyang/drafting 1.6.2

package/api/dist/routes/settings.js

@@ -0,0 +1,134 @@
+import { z } from 'zod';
+import * as repo from "../db/repos.js";
+import { parse } from "./helpers.js";
+import { config } from "../lib/config.js";
+import { aiMode } from "../providers/index.js";
+import { cliAvailable, resolveCliBin, resetCliBinCache, verifyCliAccess } from "../providers/cli.js";
+import { getDecryptedKey } from "../db/repos.js";
+import { probeGateway, fetchOpenRouterModels } from "../lib/gateway.js";
+const PROVIDERS = ['anthropic', 'openai', 'openrouter'];
+const modelEntry = z.object({
+    provider: z.enum(PROVIDERS).optional(),
+    model: z.string().optional(),
+    maxTokens: z.number().int().positive().optional(),
+});
+export async function settingsRoutes(app) {
+    // meta: version, onboarding, feature flags (SPEC-22)
+    app.get('/api/meta', async () => {
+        const keys = repo.listKeyMeta();
+        return {
+            version: config.version,
+            managedTier: config.managedTier,
+            aiStub: config.aiStub,
+            onboardingComplete: repo.getSetting('onboarding_complete') ?? false,
+            keysConfigured: keys.map((k) => k.provider),
+            aiMode: aiMode(),
+            cliAvailable: cliAvailable(),
+            cliBin: resolveCliBin(),
+            agentBinPath: repo.getSetting('agent_bin_path') ?? '',
+            openaiBaseUrl: repo.getSetting('openai_base_url') || config.openaiBaseUrl || '',
+            // In v1 there is no update server; the client shows the running version.
+            // A real deployment can point this at a release feed.
+            latestVersion: repo.getSetting('latest_version') ?? config.version,
+        };
+    });
+    app.get('/api/settings', async () => {
+        return {
+            providerModels: repo.getSetting('provider_models') ?? { default: {} },
+            onboardingComplete: repo.getSetting('onboarding_complete') ?? false,
+        };
+    });
+    // per-doc-type model + token budget (SPEC-19)
+    app.put('/api/settings/models', async (req) => {
+        const body = parse(z.object({
+            default: modelEntry.optional(),
+            prd: modelEntry.optional(),
+            'feature-spec': modelEntry.optional(),
+            ia: modelEntry.optional(),
+            'user-flow': modelEntry.optional(),
+        }), req.body);
+        const current = (repo.getSetting('provider_models') ?? {});
+        const merged = { ...current, ...body };
+        repo.setSetting('provider_models', merged);
+        return merged;
+    });
+    // OpenAI 호환 게이트웨이(LiteLLM·Azure·사내 프록시) 엔드포인트 설정.
+    // base 를 비우면 표준 OpenAI. 회사 게이트웨이 주소·키는 여기(런타임 설정)에만 둔다.
+    app.put('/api/settings/openai-endpoint', async (req) => {
+        const body = parse(z.object({
+            baseUrl: z.string().optional(),
+            headers: z.record(z.string()).optional(),
+        }), req.body ?? {});
+        if (body.headers)
+            repo.setSetting('openai_headers', body.headers);
+        const raw = (body.baseUrl ?? '').trim();
+        if (!raw) {
+            repo.setSetting('openai_base_url', '');
+            repo.setSetting('openai_models', []);
+            return { baseUrl: '', models: [], detected: 'cleared' };
+        }
+        // /v1 자동 감지 + 모델 목록 조회 (키가 있으면). 사용자는 호스트만 붙이면 된다.
+        const headers = repo.getSetting('openai_headers') ?? {};
+        const key = getDecryptedKey('openai');
+        let stored = raw.replace(/\/+$/, '');
+        let models = [];
+        let detected = key ? 'as-is' : 'no-key';
+        if (key) {
+            const probe = await probeGateway(raw, key, headers);
+            if (probe) {
+                stored = probe.chatBase;
+                models = probe.models;
+                detected = stored.endsWith('/v1') ? 'v1' : 'root';
+            }
+        }
+        repo.setSetting('openai_base_url', stored);
+        // 게이트웨이 모델 목록 저장 — 모델 미지정 시 첫 모델을 기본값으로 쓴다(claude 기본값 거부 방지).
+        repo.setSetting('openai_models', models);
+        return { baseUrl: stored, models, detected };
+    });
+    // 저장된 게이트웨이 base + openai 키로 모델 목록 재조회 (드롭다운 새로고침·마운트용)
+    // 표준 OpenRouter(BYOK) 모델 목록 — 공개 /models(키 있으면 반영). 드롭다운용.
+    app.get('/api/settings/openrouter-models', async () => {
+        const key = getDecryptedKey('openrouter') ?? undefined;
+        const models = await fetchOpenRouterModels(key);
+        return { models };
+    });
+    app.get('/api/settings/openai-models', async () => {
+        const base = repo.getSetting('openai_base_url') || config.openaiBaseUrl || '';
+        const key = getDecryptedKey('openai');
+        if (!base || !key)
+            return { models: [], baseUrl: base };
+        const headers = repo.getSetting('openai_headers') ?? {};
+        const probe = await probeGateway(base, key, headers);
+        if (probe?.models?.length)
+            repo.setSetting('openai_models', probe.models);
+        return { models: probe?.models ?? [], baseUrl: probe?.chatBase ?? base };
+    });
+    // 엔진 모드: CLI(구독) vs BYOK(API 키)
+    app.put('/api/settings/ai-mode', async (req) => {
+        const body = parse(z.object({ mode: z.enum(['cli', 'byok']) }), req.body);
+        repo.setSetting('ai_mode', body.mode);
+        return { aiMode: body.mode };
+    });
+    // 실제 생성 권한까지 검증 — 조직이 Claude Code 접근을 막은 계정을 온보딩에서 미리 잡는다.
+    app.post('/api/settings/cli/test', async () => {
+        resetCliBinCache();
+        return verifyCliAccess();
+    });
+    // CLI 바이너리 경로 수동 지정(자동 탐색이 실패하는 비표준 설치용). 빈 문자열이면 해제.
+    app.put('/api/settings/agent-bin', async (req) => {
+        const body = parse(z.object({ path: z.string() }), req.body);
+        repo.setSetting('agent_bin_path', body.path.trim());
+        resetCliBinCache();
+        return { cliBin: resolveCliBin(), cliAvailable: cliAvailable() };
+    });
+    app.post('/api/settings/onboarding/complete', async () => {
+        repo.setSetting('onboarding_complete', true);
+        return { ok: true };
+    });
+    // allow re-opening the wizard (test/dev convenience)
+    app.post('/api/settings/onboarding/reset', async () => {
+        repo.setSetting('onboarding_complete', false);
+        return { ok: true };
+    });
+}

package/api/dist/routes/share.js

@@ -0,0 +1,39 @@
+import * as repo from "../db/repos.js";
+import { documentToHtml } from "../lib/render.js";
+import { isExpired } from "./documents.js";
+// Public, read-only share view (SPEC-14). No auth — bearer is the token itself.
+export async function shareRoutes(app) {
+    app.get('/s/:token', async (req, reply) => {
+        const { token } = req.params;
+        const link = repo.getShareByToken(token);
+        reply.header('Content-Type', 'text/html; charset=utf-8');
+        if (!link || link.revoked === 1) {
+            reply.code(404);
+            return notice('링크를 찾을 수 없습니다', '이 공유 링크는 존재하지 않거나 취소되었습니다.');
+        }
+        if (isExpired(link.expires_at)) {
+            reply.code(410);
+            return notice('만료된 링크', '이 공유 링크는 만료되었습니다. 문서 소유자에게 새 링크를 요청하세요.');
+        }
+        const doc = repo.getDocument(link.document_id);
+        if (!doc) {
+            reply.code(404);
+            return notice('문서 없음', '공유된 문서가 삭제되었습니다.');
+        }
+        return documentToHtml(doc.id, { readOnly: true });
+    });
+}
+function notice(title, message) {
+    return `<!doctype html><html lang="ko"><head><meta charset="utf-8" />
+<meta name="viewport" content="width=device-width, initial-scale=1" />
+<title>${title}</title>
+<style>
+  :root { color-scheme: light dark; }
+  body { display: grid; place-items: center; min-height: 100vh; margin: 0;
+    font: 16px/1.6 -apple-system, "Pretendard", system-ui, sans-serif; background: #131315; color: #e7e7ea; }
+  .card { text-align: center; padding: 2rem; }
+  h1 { font-size: 1.4rem; margin-bottom: 0.5rem; }
+  p { color: #9a9aa0; }
+</style></head>
+<body><div class="card"><h1>${title}</h1><p>${message}</p></div></body></html>`;
+}

package/api/dist/routes/suggestions.js

@@ -0,0 +1,144 @@
+import { z } from 'zod';
+import * as repo from "../db/repos.js";
+import { HttpError, parse } from "./helpers.js";
+import { rewriteSection } from "../lib/ai.js";
+import { applyLintFixByKey } from "../lib/lint-service.js";
+const SUG_STATUSES = ['open', 'accepted', 'rejected', 'dismissed'];
+export async function suggestionRoutes(app) {
+    // ── document proposal queue (green dots / review panel) ──────────────────────
+    app.get('/api/documents/:id/suggestions', async (req) => {
+        const { id } = req.params;
+        if (!repo.getDocument(id))
+            throw new HttpError(404, 'document not found');
+        const q = parse(z.object({ status: z.enum(SUG_STATUSES).optional() }), req.query ?? {});
+        return repo.listSuggestions(id, q.status);
+    });
+    // ── accept a suggestion (SYSTEM.md §0.4 — 1st option) ────────────────────────
+    // Section becomes 'accepted'. For a 'revise', the proposed text (quote_after)
+    // is already the section body; accept just confirms it.
+    app.post('/api/suggestions/:id/accept', async (req) => {
+        const { id } = req.params;
+        const sug = repo.getSuggestion(id);
+        if (!sug)
+            throw new HttpError(404, 'suggestion not found');
+        applyAccept(sug);
+        const resolved = repo.resolveSuggestion(id, 'accepted');
+        return {
+            suggestion: resolved,
+            section: sug.section_id ? repo.getSection(sug.section_id) : null,
+        };
+    });
+    // ── reject a suggestion (SYSTEM.md §0.4 — 2nd option) ────────────────────────
+    // add    -> section 'rejected' (body kept, excluded from export)
+    // revise -> restore the ORIGINAL text (quote_before), section back to accepted
+    app.post('/api/suggestions/:id/reject', async (req) => {
+        const { id } = req.params;
+        const sug = repo.getSuggestion(id);
+        if (!sug)
+            throw new HttpError(404, 'suggestion not found');
+        applyReject(sug);
+        const resolved = repo.resolveSuggestion(id, 'rejected');
+        return {
+            suggestion: resolved,
+            section: sug.section_id ? repo.getSection(sug.section_id) : null,
+        };
+    });
+    // ── rewrite from a user instruction (SYSTEM.md §0.4 — 3rd option) ─────────────
+    // Runs the provider (stub-capable), replaces the section with a fresh proposal,
+    // resolves this suggestion as 'dismissed', and returns the NEW suggestion.
+    app.post('/api/suggestions/:id/rewrite', async (req) => {
+        const { id } = req.params;
+        const sug = repo.getSuggestion(id);
+        if (!sug)
+            throw new HttpError(404, 'suggestion not found');
+        if (!sug.section_id) {
+            throw new HttpError(400, 'this suggestion is not tied to a section and cannot be rewritten');
+        }
+        const body = parse(z.object({ instruction: z.string().min(1) }), req.body);
+        const result = await rewriteSection(sug.section_id, body.instruction);
+        if (!result)
+            throw new HttpError(404, 'section not found');
+        repo.resolveSuggestion(id, 'dismissed');
+        return { suggestion: result.suggestion, section: result.section };
+    });
+    // ── accept all open suggestions in a document ────────────────────────────────
+    app.post('/api/documents/:id/accept-all', async (req) => {
+        const { id } = req.params;
+        const doc = repo.getDocument(id);
+        if (!doc)
+            throw new HttpError(404, 'document not found');
+        const open = repo.listSuggestions(id, 'open');
+        // 파괴적 제안(lint 정리 = 대상 항목 제외, delete = 섹션 제외)은 일괄 수락에서
+        // 제외한다 — 정합성 지적을 '모두 수락'하면 지적된 항목이 통째로 사라지는 사고 방지.
+        // 파괴적 제안은 카드에서 개별적으로만 수락할 수 있다.
+        const safe = open.filter((s) => s.kind !== 'lint' && s.kind !== 'delete');
+        for (const sug of safe) {
+            applyAccept(sug);
+            repo.resolveSuggestion(sug.id, 'accepted');
+        }
+        // Accepting all resolves a stale document (context is now reviewed).
+        if (doc.context_stale === 1 && repo.countOpenSuggestions(id) === 0) {
+            repo.refreshContext(id);
+        }
+        return {
+            accepted: safe.length,
+            skippedDestructive: open.length - safe.length,
+            sections: repo.listSections(id),
+            openRemaining: repo.countOpenSuggestions(id),
+        };
+    });
+}
+function applyAccept(sug) {
+    // lint suggestion accepted -> apply the code's default remediation (§4.2)
+    if (sug.kind === 'lint') {
+        const doc = repo.getDocument(sug.document_id);
+        if (doc && sug.quote_before)
+            applyLintFixByKey(doc.project_id, sug.quote_before);
+        return;
+    }
+    // structure-doc item proposal accepted -> the item becomes the document (§1.3)
+    if (sug.target_item_id) {
+        repo.setItemStatus(sug.target_item_id, 'accepted');
+        return;
+    }
+    if (!sug.section_id)
+        return; // document-level (e.g. question/stale) — nothing to flip
+    const section = repo.getSection(sug.section_id);
+    if (!section)
+        return;
+    if (sug.kind === 'delete') {
+        // a delete proposal, once accepted, excludes the section from the document
+        repo.setSectionStatus(section.id, 'rejected');
+        return;
+    }
+    // add / revise / question / stale -> the (proposed) body becomes the document
+    repo.setSectionStatus(section.id, 'accepted');
+}
+function applyReject(sug) {
+    // lint suggestion rejected = waive (§4.3) — nothing to mutate; the rejected
+    // status itself records the waive (read by lint-service.waivedKeys).
+    if (sug.kind === 'lint')
+        return;
+    // structure-doc item proposal rejected -> the item is excluded from the document
+    if (sug.target_item_id) {
+        repo.setItemStatus(sug.target_item_id, 'rejected');
+        return;
+    }
+    if (!sug.section_id)
+        return;
+    const section = repo.getSection(sug.section_id);
+    if (!section)
+        return;
+    if (sug.kind === 'revise' && sug.quote_before) {
+        // keep the original text (SYSTEM.md §0.4): revert body, re-accept the section
+        repo.updateSection(section.id, { body: sug.quote_before });
+        repo.setSectionStatus(section.id, 'accepted');
+        return;
+    }
+    if (sug.kind === 'add') {
+        // reject an added section: body kept but excluded from export
+        repo.setSectionStatus(section.id, 'rejected');
+        return;
+    }
+    // delete/question/stale rejected -> leave the section as-is
+}

package/api/templates/design-system.json

@@ -0,0 +1,17 @@
+{
+  "id": "design-system",
+  "docType": "design-system",
+  "name": "디자인 시스템",
+  "description": "제품의 색·타이포·간격·형태·컴포넌트·톤을 인터뷰로 설계한다. 와이어프레임·시안이 이 시스템으로 렌더된다.",
+  "draftGuidance": "인터뷰 답변과 상위 PRD 맥락으로 이 제품에 맞는 디자인 시스템을 설계한다. 색은 단일 강조색이 아니라 역할(배경·표면·본문·보조·경계·강조·상태) 체계로 잡고, 강조색은 주요 액션·활성 상태에만 절제해서 쓴다.",
+  "questions": [
+    { "id": "personality", "prompt": "제품이 주는 느낌을 형용사 3개로 표현하면? (사용자가 첫인상으로 느꼈으면 하는 것)", "hint": "예: 신뢰·차분·전문 / 활기·친근·경쾌", "example": "신뢰감 있고 차분하며 전문적" },
+    { "id": "reference", "prompt": "비슷한 느낌의 제품이나 브랜드가 있나요? 왜 그 느낌인가요?", "hint": "구체적인 제품명 + 어떤 점이 좋은지", "example": "Linear — 절제된 색과 촘촘한 정보 밀도가 전문적이라서" },
+    { "id": "context", "prompt": "주로 어디서·어떤 환경에서 쓰나요? (모바일/데스크톱, 밝은 곳/어두운 곳)", "hint": "라이트/다크, 화면 크기, 사용 상황", "example": "데스크톱 위주, 밝은 사무실, 라이트 모드" },
+    { "id": "color", "prompt": "브랜드 색이나 강조색이 있나요? 없다면 성격에서 도출합니다. 피해야 할 색은?", "hint": "HEX 있으면 좋고, 금지색도 적어주세요", "example": "강조는 딥 그린 계열, 빨강은 피하고 싶음" },
+    { "id": "typography", "prompt": "서체 성격과 정보 밀도 취향은? (모던 산세리프 / 클래식 세리프 / 친근 라운드 / 기능적 모노, 촘촘 vs 여유)", "hint": "읽는 느낌 + 화면당 정보량", "example": "모던 산세리프, 정보는 촘촘하게" },
+    { "id": "components", "prompt": "형태 취향은? (각진 vs 둥근 모서리, 그림자·보더, 버튼·카드 느낌)", "hint": "딱딱함↔부드러움, 플랫↔입체", "example": "약간 둥근 모서리, 그림자는 최소, 플랫한 카드" },
+    { "id": "accessibility", "prompt": "접근성이나 지켜야 할 제약이 있나요? (고대비, 색맹 대응, 특정 규정·금지)", "hint": "없으면 '없음'", "example": "고대비 필요, 색만으로 상태 구분 금지" }
+  ],
+  "sections": ["색 시스템", "타이포그래피", "간격·형태", "컴포넌트", "톤 & 보이스"]
+}

package/api/templates/feature-spec.json

@@ -0,0 +1,73 @@
+{
+  "id": "feature-spec",
+  "docType": "feature-spec",
+  "name": "기능명세서",
+  "description": "PRD의 각 기능을 동작·데이터·수용 기준 수준으로 구체화하는 문서.",
+  "draftGuidance": "너는 시니어 프로덕트 엔지니어다. 상위 PRD 컨텍스트가 주어지면 그 목표와 정합하도록, 각 기능을 사용자 스토리·동작 규칙·수용 기준(체크리스트)·엣지케이스 수준으로 구체화한다. 구현 결정은 검증 가능하게 쓴다. 한국어로 작성한다.",
+  "questions": [
+    {
+      "id": "target_feature",
+      "prompt": "이번 명세의 대상 기능은 무엇인가요? (PRD의 어떤 항목)",
+      "hint": "한 번에 한 기능에 집중.",
+      "example": "단계별 AI 인터뷰"
+    },
+    {
+      "id": "user_story",
+      "prompt": "핵심 사용자 스토리를 적어주세요. (누가/무엇을/왜)",
+      "hint": "As a … I want … so that … 형식.",
+      "example": "PM으로서 질문에 답하면 초안이 생성되길 원한다, 빈 화면을 피하려고."
+    },
+    {
+      "id": "rules",
+      "prompt": "이 기능의 핵심 동작 규칙·제약은 무엇인가요?",
+      "hint": "허용/금지, 상태 전이, 검증 규칙.",
+      "example": "답변 미완료 시 초안 생성 버튼 비활성, 세션 자동 저장."
+    },
+    {
+      "id": "data",
+      "prompt": "어떤 데이터를 입력받고 무엇을 저장/출력하나요?",
+      "hint": "입력·저장·출력 필드.",
+      "example": "입력: 질문 답변 / 저장: 세션·섹션 / 출력: 스트리밍 섹션"
+    },
+    {
+      "id": "acceptance",
+      "prompt": "완료를 판단할 수용 기준은 무엇인가요?",
+      "hint": "체크리스트로 검증 가능하게.",
+      "example": "탭 닫고 재접속 시 이전 답변 복원, 재생성은 해당 섹션만 교체."
+    },
+    {
+      "id": "edge",
+      "prompt": "주의할 엣지케이스·실패 모드는 무엇인가요?",
+      "hint": "네트워크 끊김, 빈 입력, 동시 편집 등.",
+      "example": "스트리밍 중 새로고침, AI 키 미등록, 매우 긴 답변."
+    }
+  ],
+  "sections": [
+    "기능 개요",
+    "사용자 스토리",
+    "동작 규칙 및 제약",
+    "데이터 입출력",
+    "수용 기준",
+    "엣지케이스 및 실패 처리"
+  ],
+  "itemSchema": {
+    "root": "groups",
+    "note": "번호(F-)는 서버가 매긴다. LLM 은 내용만 반환한다.",
+    "shape": {
+      "groups": [
+        {
+          "title": "string",
+          "features": [
+            {
+              "title": "string",
+              "body": "string (수용 기준, 줄바꿈 구분)",
+              "priority": "P0|P1|P2",
+              "source": "REQ-01|Q3|PRD §4",
+              "links": { "reqs": ["REQ-01"], "pages": ["PG-02"], "flows": ["FLOW-01"] }
+            }
+          ]
+        }
+      ]
+    }
+  }
+}

package/api/templates/ia.json

@@ -0,0 +1,52 @@
+{
+  "id": "ia",
+  "docType": "ia",
+  "name": "정보구조 (IA)",
+  "description": "제품의 화면·네비게이션·콘텐츠 계층 구조를 정의하는 문서. (v2 우선 확장)",
+  "draftGuidance": "너는 인포메이션 아키텍트다. 상위 문서의 기능들을 화면과 네비게이션 계층으로 조직한다. 화면 목록, 계층(트리), 화면 간 이동, 주요 콘텐츠 블록을 명확히 한다. 한국어로 작성한다.",
+  "questions": [
+    {
+      "id": "top_nav",
+      "prompt": "최상위 네비게이션(주요 영역)은 무엇으로 나눌까요?",
+      "hint": "3~6개의 최상위 영역.",
+      "example": "프로젝트, 문서 워크스페이스, 설정"
+    },
+    {
+      "id": "screens",
+      "prompt": "핵심 화면 목록을 적어주세요.",
+      "hint": "각 화면의 목적 한 줄.",
+      "example": "프로젝트 목록, 문서 워크스페이스, BYOK 설정 위저드"
+    },
+    {
+      "id": "hierarchy",
+      "prompt": "콘텐츠 계층 구조는 어떻게 되나요? (상위→하위)",
+      "hint": "프로젝트 > 문서 > 섹션 식.",
+      "example": "프로젝트 > 문서(PRD/기능명세) > 섹션"
+    },
+    {
+      "id": "flows_entry",
+      "prompt": "사용자가 가장 자주 진입하는 경로는 무엇인가요?",
+      "hint": "주요 진입점과 목적지.",
+      "example": "대시보드 → 프로젝트 → 문서 작성"
+    }
+  ],
+  "sections": [
+    "네비게이션 구조",
+    "화면 목록",
+    "콘텐츠 계층",
+    "주요 이동 경로"
+  ],
+  "itemSchema": {
+    "root": "pages",
+    "note": "번호(PG-)는 서버가 매긴다. LLM 은 내용만 반환한다.",
+    "shape": {
+      "pages": [
+        {
+          "title": "string",
+          "page_type": "LIST|DETAIL|FORM|DASH|SETTINGS|GENERIC",
+          "links": { "features": ["F-01-1"] }
+        }
+      ]
+    }
+  }
+}

package/api/templates/prd.json

@@ -0,0 +1,60 @@
+{
+  "id": "prd",
+  "docType": "prd",
+  "name": "PRD (제품 요구사항 문서)",
+  "description": "제품의 배경·문제·목표·범위를 정의하는 최상위 기획 문서.",
+  "draftGuidance": "너는 숙련된 프로덕트 매니저다. 아래 인터뷰 답변을 바탕으로 명확하고 검증 가능한 PRD 섹션을 작성한다. 모호한 미사여구를 피하고, 측정 가능한 목표와 구체적 사용자 시나리오를 쓴다. 한국어로 작성한다.",
+  "questions": [
+    {
+      "id": "problem",
+      "prompt": "어떤 문제를 해결하려 하나요? 지금 사용자는 이 문제를 어떻게 겪고 있나요?",
+      "hint": "현상(as-is)의 고통 지점을 구체적으로.",
+      "example": "IT 기획자가 PRD를 매번 백지에서 시작해 반나절씩 소모한다."
+    },
+    {
+      "id": "audience",
+      "prompt": "핵심 대상 사용자는 누구인가요? (역할·상황)",
+      "hint": "1차 사용자와 2차 이해관계자를 구분.",
+      "example": "1차: 스타트업 PM / 2차: 개발팀 리드, 외부 클라이언트"
+    },
+    {
+      "id": "value",
+      "prompt": "이 제품이 제공하는 핵심 가치 한 문장은 무엇인가요?",
+      "hint": "'무엇을 더 빠르게/저렴하게/정확하게' 형태로.",
+      "example": "AI 인터뷰로 PRD 초안을 30분 내 완성한다."
+    },
+    {
+      "id": "goals",
+      "prompt": "성공을 어떻게 측정하나요? 측정 가능한 목표 지표를 적어주세요.",
+      "hint": "정량 지표 위주(시간·비율·횟수).",
+      "example": "문서 1건 작성 시간 4시간 → 30분, 주간 활성 프로젝트 20건."
+    },
+    {
+      "id": "features",
+      "prompt": "MVP에 반드시 있어야 하는 핵심 기능 3~5가지는 무엇인가요?",
+      "hint": "‘있으면 좋은 것’은 제외하고 필수만.",
+      "example": "단계별 AI 인터뷰, 스트리밍 초안, 구조 편집기, MD 내보내기"
+    },
+    {
+      "id": "nonscope",
+      "prompt": "이번 버전에서 명시적으로 다루지 않을 범위(비범위)는 무엇인가요?",
+      "hint": "스코프 크리프 방지용.",
+      "example": "실시간 협업, 결제, 모바일 앱은 v2 이후."
+    },
+    {
+      "id": "risks",
+      "prompt": "가장 큰 리스크와 가정은 무엇인가요?",
+      "hint": "틀리면 제품이 흔들리는 전제.",
+      "example": "사용자가 자신의 AI 키를 기꺼이 등록한다는 가정."
+    }
+  ],
+  "sections": [
+    "개요 및 배경",
+    "문제 정의",
+    "목표와 성공 지표",
+    "대상 사용자",
+    "핵심 기능 (MVP)",
+    "범위 및 비범위",
+    "리스크와 가정"
+  ]
+}

package/api/templates/user-flow.json

@@ -0,0 +1,61 @@
+{
+  "id": "user-flow",
+  "docType": "user-flow",
+  "name": "유저플로우",
+  "description": "주요 시나리오별 사용자 단계와 분기·예외를 정의하는 문서. (v2 우선 확장)",
+  "draftGuidance": "너는 UX 디자이너다. 상위 문서(IA/기능명세)에 정합하도록 핵심 시나리오의 단계별 흐름을 작성한다. 각 단계의 사용자 행동·시스템 반응·분기(성공/실패)를 명확히 한다. 한국어로 작성한다.",
+  "questions": [
+    {
+      "id": "scenario",
+      "prompt": "어떤 핵심 시나리오를 흐름으로 그릴까요?",
+      "hint": "가장 중요한 여정 1개.",
+      "example": "신규 사용자가 첫 PRD를 완성하기까지"
+    },
+    {
+      "id": "entry",
+      "prompt": "시작 지점과 사용자의 목표는 무엇인가요?",
+      "hint": "트리거와 최종 목적.",
+      "example": "설치 직후 → PRD 초안 확보"
+    },
+    {
+      "id": "happy_path",
+      "prompt": "가장 이상적인 성공 경로의 단계들을 순서대로 적어주세요.",
+      "hint": "행동 → 반응 → 다음.",
+      "example": "키 등록 → 프로젝트 생성 → 인터뷰 → 스트리밍 → 편집 → 내보내기"
+    },
+    {
+      "id": "branches",
+      "prompt": "주요 분기·예외(실패) 경로는 무엇인가요?",
+      "hint": "이탈·오류·되돌아가기.",
+      "example": "AI 키 오류 시 설정으로 유도, 스트리밍 중단 시 재개."
+    }
+  ],
+  "sections": [
+    "시나리오 개요",
+    "진입 및 목표",
+    "성공 경로 (Happy Path)",
+    "분기 및 예외 경로"
+  ],
+  "itemSchema": {
+    "root": "flows",
+    "note": "번호(FLOW-)는 서버가 매긴다. LLM 은 내용만 반환한다.",
+    "shape": {
+      "flows": [
+        {
+          "title": "string",
+          "source": "F-01",
+          "links": { "features": ["F-01"] },
+          "steps": [
+            {
+              "title": "string",
+              "page": "PG-02|null",
+              "node": "start|screen|decision|end",
+              "branch": { "label": "예", "from_step": "FLOW-01.4" },
+              "note": "겹침 재판정"
+            }
+          ]
+        }
+      ]
+    }
+  }
+}