@hanmariyang/drafting 1.6.2

package/api/dist/routes/documents.js

@@ -0,0 +1,205 @@
+import { z } from 'zod';
+import * as repo from "../db/repos.js";
+import { HttpError, parse } from "./helpers.js";
+import { documentToMarkdown, documentToHtml } from "../lib/render.js";
+import { nowIso } from "../db/index.js";
+const DOC_TYPES = ['prd', 'feature-spec', 'ia', 'user-flow', 'design-system'];
+export async function documentRoutes(app) {
+    // create a document under a project
+    app.post('/api/projects/:pid/documents', async (req) => {
+        const { pid } = req.params;
+        if (!repo.getProject(pid))
+            throw new HttpError(404, 'project not found');
+        const body = parse(z.object({
+            type: z.enum(DOC_TYPES),
+            title: z.string().min(1),
+            parentDocumentId: z.string().nullable().optional(),
+        }), req.body);
+        if (body.parentDocumentId && !repo.getDocument(body.parentDocumentId)) {
+            throw new HttpError(400, 'parent document not found');
+        }
+        return repo.createDocument({
+            projectId: pid,
+            type: body.type,
+            title: body.title,
+            parentDocumentId: body.parentDocumentId ?? null,
+        });
+    });
+    // full document view: doc + sections + session + context state
+    app.get('/api/documents/:id', async (req) => {
+        const { id } = req.params;
+        const doc = repo.getDocument(id);
+        if (!doc)
+            throw new HttpError(404, 'document not found');
+        return {
+            document: doc,
+            sections: repo.listSections(id),
+            session: repo.getSessionByDocument(id),
+            parentContextAvailable: repo.getParentContext(id) !== null,
+            openSuggestions: repo.countOpenSuggestions(id),
+        };
+    });
+    app.patch('/api/documents/:id', async (req) => {
+        const { id } = req.params;
+        const body = parse(z.object({ title: z.string().min(1) }), req.body);
+        const updated = repo.updateDocumentTitle(id, body.title);
+        if (!updated)
+            throw new HttpError(404, 'document not found');
+        return updated;
+    });
+    app.delete('/api/documents/:id', async (req) => {
+        const { id } = req.params;
+        if (!repo.getDocument(id))
+            throw new HttpError(404, 'document not found');
+        repo.deleteDocument(id);
+        return { ok: true };
+    });
+    // ── sections ──────────────────────────────────────────────────────────────
+    app.get('/api/documents/:id/sections', async (req) => {
+        const { id } = req.params;
+        if (!repo.getDocument(id))
+            throw new HttpError(404, 'document not found');
+        return repo.listSections(id);
+    });
+    app.post('/api/documents/:id/sections', async (req) => {
+        const { id } = req.params;
+        if (!repo.getDocument(id))
+            throw new HttpError(404, 'document not found');
+        const body = parse(z.object({ heading: z.string(), body: z.string().optional() }), req.body);
+        const section = repo.createSection(id, body.heading, body.body ?? '');
+        repo.snapshotDocument(id, 'save', { reason: 'add_section' });
+        return section;
+    });
+    app.patch('/api/sections/:sid', async (req) => {
+        const { sid } = req.params;
+        const section = repo.getSection(sid);
+        if (!section)
+            throw new HttpError(404, 'section not found');
+        const body = parse(z.object({ heading: z.string().optional(), body: z.string().optional() }), req.body);
+        const updated = repo.updateSection(sid, body);
+        // A manual edit is a structural change -> version bump + child staleness.
+        repo.snapshotDocument(section.document_id, 'save', { reason: 'edit_section', sectionId: sid });
+        return updated;
+    });
+    app.delete('/api/sections/:sid', async (req) => {
+        const { sid } = req.params;
+        const section = repo.getSection(sid);
+        if (!section)
+            throw new HttpError(404, 'section not found');
+        repo.deleteSection(sid);
+        repo.snapshotDocument(section.document_id, 'save', { reason: 'delete_section' });
+        return { ok: true };
+    });
+    app.post('/api/documents/:id/sections/reorder', async (req) => {
+        const { id } = req.params;
+        if (!repo.getDocument(id))
+            throw new HttpError(404, 'document not found');
+        const body = parse(z.object({ orderedIds: z.array(z.string()) }), req.body);
+        const sections = repo.reorderSections(id, body.orderedIds);
+        repo.snapshotDocument(id, 'save', { reason: 'reorder' });
+        return sections;
+    });
+    // ── context chain (P-01) ────────────────────────────────────────────────────
+    app.get('/api/documents/:id/context/parent', async (req) => {
+        const { id } = req.params;
+        if (!repo.getDocument(id))
+            throw new HttpError(404, 'document not found');
+        const ctx = repo.getParentContext(id);
+        if (!ctx)
+            return { available: false };
+        return { available: true, ...ctx };
+    });
+    app.post('/api/documents/:id/context/refresh', async (req) => {
+        const { id } = req.params;
+        if (!repo.getDocument(id))
+            throw new HttpError(404, 'document not found');
+        // Only 'context-only' is supported here. Section regeneration (flow B) is
+        // driven per-section by the client via the regenerate endpoint (SPEC-07).
+        const body = parse(z.object({ mode: z.literal('context-only').default('context-only') }), req.body ?? {});
+        void body;
+        const updated = repo.refreshContext(id);
+        return updated;
+    });
+    // ── versions (SPEC-12) ──────────────────────────────────────────────────────
+    app.get('/api/documents/:id/versions', async (req) => {
+        const { id } = req.params;
+        if (!repo.getDocument(id))
+            throw new HttpError(404, 'document not found');
+        return repo.listVersions(id).map((v) => ({ ...v, meta: JSON.parse(v.meta) }));
+    });
+    app.post('/api/documents/:id/versions/:vid/restore', async (req) => {
+        const { id, vid } = req.params;
+        const restored = repo.restoreVersion(id, vid);
+        if (!restored)
+            throw new HttpError(404, 'version not found');
+        return {
+            document: restored,
+            sections: repo.listSections(id),
+        };
+    });
+    // 되돌리기(undo) — 직전 스냅샷으로 1단계 복원. 더 깊은 복원은 버전 기록 사용.
+    app.post('/api/documents/:id/undo', async (req) => {
+        const { id } = req.params;
+        if (!repo.getDocument(id))
+            throw new HttpError(404, 'document not found');
+        const versions = repo.listVersions(id); // 최신순
+        if (versions.length < 2)
+            throw new HttpError(400, '되돌릴 변경이 없습니다');
+        const restored = repo.restoreVersion(id, versions[1].id);
+        if (!restored)
+            throw new HttpError(404, 'version not found');
+        return { document: restored, sections: repo.listSections(id) };
+    });
+    // ── export (SPEC-13/14) ─────────────────────────────────────────────────────
+    app.get('/api/documents/:id/export.md', async (req, reply) => {
+        const { id } = req.params;
+        if (!repo.getDocument(id))
+            throw new HttpError(404, 'document not found');
+        reply
+            .header('Content-Type', 'text/markdown; charset=utf-8')
+            .header('Content-Disposition', `attachment; filename="${id}.md"`);
+        return documentToMarkdown(id);
+    });
+    app.get('/api/documents/:id/export.html', async (req, reply) => {
+        const { id } = req.params;
+        if (!repo.getDocument(id))
+            throw new HttpError(404, 'document not found');
+        // ?print=1 → 로드 시 인쇄 대화상자 자동 실행(브라우저 'PDF로 저장'). 의존성 없는 PDF 경로.
+        const print = req.query?.print === '1';
+        reply.header('Content-Type', 'text/html; charset=utf-8');
+        return documentToHtml(id, { print });
+    });
+    // ── share links (SPEC-14) ───────────────────────────────────────────────────
+    app.post('/api/documents/:id/shares', async (req) => {
+        const { id } = req.params;
+        if (!repo.getDocument(id))
+            throw new HttpError(404, 'document not found');
+        const body = parse(z.object({ expiresInHours: z.number().positive().nullable().optional() }), req.body ?? {});
+        let expiresAt = null;
+        if (body.expiresInHours) {
+            expiresAt = new Date(Date.now() + body.expiresInHours * 3600_000).toISOString();
+        }
+        const link = repo.createShareLink(id, expiresAt);
+        return { ...link, url: `/s/${link.token}` };
+    });
+    app.get('/api/documents/:id/shares', async (req) => {
+        const { id } = req.params;
+        if (!repo.getDocument(id))
+            throw new HttpError(404, 'document not found');
+        return repo.listShareLinks(id).map((l) => ({
+            ...l,
+            url: `/s/${l.token}`,
+            expired: isExpired(l.expires_at),
+        }));
+    });
+    app.post('/api/shares/:sid/revoke', async (req) => {
+        const { sid } = req.params;
+        repo.revokeShareLink(sid);
+        return { ok: true, at: nowIso() };
+    });
+}
+export function isExpired(expiresAt) {
+    if (!expiresAt)
+        return false;
+    return new Date(expiresAt).getTime() < Date.now();
+}

package/api/dist/routes/helpers.js

@@ -0,0 +1,43 @@
+export class HttpError extends Error {
+    status;
+    constructor(status, message) {
+        super(message);
+        this.status = status;
+    }
+}
+export function parse(schema, body) {
+    const result = schema.safeParse(body);
+    if (!result.success) {
+        const msg = result.error.issues
+            .map((i) => `${i.path.join('.') || '(body)'}: ${i.message}`)
+            .join('; ');
+        throw new HttpError(400, msg);
+    }
+    return result.data;
+}
+/**
+ * Set up a Server-Sent Events stream on the raw response and return a writer.
+ * Wires an AbortController to the client disconnect so upstream AI calls stop.
+ */
+export function sseStream(request, reply) {
+    // take over the socket so Fastify does not also try to send a reply
+    reply.hijack();
+    reply.raw.writeHead(200, {
+        'Content-Type': 'text/event-stream',
+        'Cache-Control': 'no-cache, no-transform',
+        Connection: 'keep-alive',
+        'X-Accel-Buffering': 'no',
+    });
+    const controller = new AbortController();
+    request.raw.on('close', () => controller.abort());
+    return {
+        signal: controller.signal,
+        send(event, data) {
+            reply.raw.write(`event: ${event}\n`);
+            reply.raw.write(`data: ${JSON.stringify(data)}\n\n`);
+        },
+        end() {
+            reply.raw.end();
+        },
+    };
+}

package/api/dist/routes/interview.js

@@ -0,0 +1,141 @@
+import { z } from 'zod';
+import * as repo from "../db/repos.js";
+import { HttpError, parse, sseStream } from "./helpers.js";
+import { listTemplates, getTemplate, getTemplateForType, templateSource, saveCustomTemplate, deleteCustomTemplate, } from "../lib/templates.js";
+import { streamDocumentDraft, streamSectionRegeneration } from "../lib/ai.js";
+export async function interviewRoutes(app) {
+    // ── templates (SPEC-01/02) + 라이브러리 편집 ─────────────────────────────────
+    app.get('/api/templates', async () => listTemplates().map((t) => ({ ...t, source: templateSource(t.id) })));
+    app.get('/api/templates/:id', async (req) => {
+        const { id } = req.params;
+        const t = getTemplate(id);
+        if (!t)
+            throw new HttpError(404, 'template not found');
+        return { ...t, source: templateSource(id) };
+    });
+    // 커스텀 템플릿 생성/수정 — 파일 템플릿 위에 DB 로 오버레이(파일 미수정, G-06 유지).
+    app.put('/api/templates/:id', async (req) => {
+        const { id } = req.params;
+        const body = parse(TEMPLATE_SCHEMA, req.body);
+        if (body.id !== id)
+            throw new HttpError(400, 'id 가 경로와 일치해야 합니다');
+        saveCustomTemplate(body);
+        return { ...getTemplate(id), source: templateSource(id) };
+    });
+    // 커스텀 삭제 — 오버라이드면 파일 버전으로 복귀, 순수 커스텀이면 제거.
+    app.delete('/api/templates/:id', async (req) => {
+        const { id } = req.params;
+        const removed = deleteCustomTemplate(id);
+        if (!removed)
+            throw new HttpError(404, '커스텀 템플릿이 아닙니다(파일 템플릿은 삭제 불가)');
+        const reverted = getTemplate(id);
+        return { ok: true, reverted: reverted ? { ...reverted, source: templateSource(id) } : null };
+    });
+    // ── interview session (SPEC-03 autosave/resume) ─────────────────────────────
+    app.get('/api/documents/:id/interview', async (req) => {
+        const { id } = req.params;
+        const doc = repo.getDocument(id);
+        if (!doc)
+            throw new HttpError(404, 'document not found');
+        const session = repo.getSessionByDocument(id);
+        const template = getTemplateForType(doc.type);
+        return { session, template };
+    });
+    // create (or return existing) session for a document
+    app.post('/api/documents/:id/interview', async (req) => {
+        const { id } = req.params;
+        const doc = repo.getDocument(id);
+        if (!doc)
+            throw new HttpError(404, 'document not found');
+        const template = getTemplateForType(doc.type);
+        if (!template)
+            throw new HttpError(400, `no interview template for type ${doc.type}`);
+        let session = repo.getSessionByDocument(id);
+        if (!session)
+            session = repo.createSession(id, template.id);
+        return { session, template };
+    });
+    // autosave a single answer + progress index (SPEC-03)
+    app.post('/api/interview/:sid/answer', async (req) => {
+        const { sid } = req.params;
+        const session = repo.getSession(sid);
+        if (!session)
+            throw new HttpError(404, 'session not found');
+        const body = parse(z.object({
+            questionId: z.string(),
+            question: z.string(),
+            answer: z.string(),
+            currentIndex: z.number().int().nonnegative().optional(),
+        }), req.body);
+        const answers = [...session.answers];
+        const existing = answers.findIndex((a) => a.questionId === body.questionId);
+        const entry = { questionId: body.questionId, question: body.question, answer: body.answer };
+        if (existing >= 0)
+            answers[existing] = entry;
+        else
+            answers.push(entry);
+        return repo.updateSession(sid, {
+            answers,
+            current_index: body.currentIndex ?? session.current_index,
+        });
+    });
+    app.post('/api/interview/:sid/complete', async (req) => {
+        const { sid } = req.params;
+        const session = repo.getSession(sid);
+        if (!session)
+            throw new HttpError(404, 'session not found');
+        return repo.updateSession(sid, { status: 'complete' });
+    });
+    // ── draft streaming (SPEC-06, SSE) ──────────────────────────────────────────
+    // GET so it works with EventSource. Streams the whole document draft.
+    app.get('/api/documents/:id/draft/stream', async (req, reply) => {
+        const { id } = req.params;
+        if (!repo.getDocument(id))
+            throw new HttpError(404, 'document not found');
+        await pipeDraft((signal) => streamDocumentDraft(id, signal), req, reply);
+    });
+    // regenerate a single section (SPEC-07, SSE)
+    app.get('/api/sections/:sid/regenerate/stream', async (req, reply) => {
+        const { sid } = req.params;
+        if (!repo.getSection(sid))
+            throw new HttpError(404, 'section not found');
+        await pipeDraft((signal) => streamSectionRegeneration(sid, signal), req, reply);
+    });
+}
+async function pipeDraft(makeGen, req, reply) {
+    const sse = sseStream(req, reply);
+    // 클라이언트가 '중지'로 연결을 끊으면 signal 이 abort 되어 provider 호출까지 멈춘다(토큰 절약).
+    const gen = makeGen(sse.signal);
+    try {
+        for await (const evt of gen) {
+            const { type, ...rest } = evt;
+            sse.send(type, rest);
+            if (evt.type === 'done' || evt.type === 'error')
+                break;
+        }
+    }
+    catch (e) {
+        sse.send('error', { message: e.message });
+    }
+    finally {
+        sse.end();
+    }
+}
+const DOC_TYPES = ['prd', 'feature-spec', 'ia', 'user-flow', 'design-system', 'handoff'];
+const TEMPLATE_SCHEMA = z.object({
+    id: z.string().min(1).max(60).regex(/^[a-z0-9-]+$/, 'id 는 소문자·숫자·하이픈만'),
+    docType: z.enum(DOC_TYPES),
+    name: z.string().min(1).max(120),
+    description: z.string().max(400).default(''),
+    questions: z
+        .array(z.object({
+        id: z.string().min(1).max(40),
+        prompt: z.string().min(1).max(600),
+        hint: z.string().max(300).optional(),
+        example: z.string().max(400).optional(),
+    }))
+        .min(1, '질문이 최소 1개 필요합니다'),
+    sections: z.array(z.string().min(1).max(80)).min(1, '섹션이 최소 1개 필요합니다'),
+    draftGuidance: z.string().min(1).max(2000),
+    itemSchema: z.unknown().optional(),
+});

package/api/dist/routes/keys.js

@@ -0,0 +1,70 @@
+import { z } from 'zod';
+import * as repo from "../db/repos.js";
+import { HttpError, parse } from "./helpers.js";
+import { resolveProvider } from "../providers/index.js";
+import { getModelConfig } from "../lib/ai.js";
+import { probeGateway } from "../lib/gateway.js";
+import { config } from "../lib/config.js";
+const PROVIDERS = ['anthropic', 'openai', 'openrouter'];
+export async function keyRoutes(app) {
+    // masked list — never returns key material (G-01)
+    app.get('/api/keys', async () => {
+        const configured = repo.listKeyMeta();
+        return PROVIDERS.map((p) => {
+            const meta = configured.find((k) => k.provider === p);
+            return {
+                provider: p,
+                configured: !!meta,
+                label: meta?.label ?? '',
+                last4: meta?.last4 ?? '',
+                updatedAt: meta?.updated_at ?? null,
+            };
+        });
+    });
+    app.put('/api/keys/:provider', async (req) => {
+        const provider = validProvider(req.params);
+        const body = parse(z.object({ key: z.string().min(8), label: z.string().optional() }), req.body);
+        const meta = repo.upsertApiKey(provider, body.key.trim(), body.label ?? '');
+        return { provider: meta.provider, configured: true, last4: meta.last4 };
+    });
+    app.delete('/api/keys/:provider', async (req) => {
+        const provider = validProvider(req.params);
+        repo.deleteApiKey(provider);
+        return { ok: true };
+    });
+    // test call (SPEC-18) — uses stored key (or stub/managed per env)
+    app.post('/api/keys/:provider/test', async (req) => {
+        const provider = validProvider(req.params);
+        const body = parse(z.object({ model: z.string().optional() }), req.body ?? {});
+        let ai;
+        try {
+            ai = resolveProvider(provider, { forceByok: true }); // 키 테스트는 항상 BYOK 경로
+        }
+        catch (e) {
+            throw new HttpError(400, e.message);
+        }
+        // 테스트 모델 선정: 명시값 > (openai 게이트웨이면) 게이트웨이가 실제 제공하는 모델 > 설정 기본값.
+        // 게이트웨이는 gpt-4o-mini 등 기본 모델 권한이 없어 401 이 나므로, 실 모델로 테스트한다.
+        let model = body.model;
+        if (!model && (provider === 'openai' || provider === 'openrouter')) {
+            const base = repo.getSetting('openai_base_url') || config.openaiBaseUrl || '';
+            if (base) {
+                const key = repo.getDecryptedKey(provider);
+                const headers = repo.getSetting('openai_headers') ?? {};
+                const probe = key ? await probeGateway(base, key, headers) : null;
+                const configured = getModelConfig('prd').model;
+                model = probe?.models?.includes(configured) ? configured : probe?.models?.[0];
+            }
+        }
+        model = model ?? getModelConfig('prd').model;
+        const result = await ai.testConnection(model);
+        return { provider, model, ...result };
+    });
+}
+function validProvider(params) {
+    const { provider } = params;
+    if (!PROVIDERS.includes(provider)) {
+        throw new HttpError(400, `unknown provider: ${provider}`);
+    }
+    return provider;
+}

package/api/dist/routes/projects.js

@@ -0,0 +1,103 @@
+import { z } from 'zod';
+import * as repo from "../db/repos.js";
+import { HttpError, parse } from "./helpers.js";
+export async function projectRoutes(app) {
+    app.get('/api/projects', async () => {
+        return repo.listProjects().map((p) => ({
+            ...p,
+            documentCount: repo.listDocuments(p.id).length,
+        }));
+    });
+    app.post('/api/projects', async (req) => {
+        const body = parse(z.object({ name: z.string().min(1), description: z.string().optional() }), req.body);
+        return repo.createProject(body.name, body.description ?? '');
+    });
+    app.get('/api/projects/:id', async (req) => {
+        const { id } = req.params;
+        const project = repo.getProject(id);
+        if (!project)
+            throw new HttpError(404, 'project not found');
+        // open_suggestions drives the tree green dot (SYSTEM.md §2).
+        const documents = repo.listDocuments(id).map((d) => ({
+            ...d,
+            open_suggestions: repo.countOpenSuggestions(d.id),
+        }));
+        return { ...project, documents };
+    });
+    app.patch('/api/projects/:id', async (req) => {
+        const { id } = req.params;
+        const body = parse(z.object({ name: z.string().min(1).optional(), description: z.string().optional() }), req.body);
+        const updated = repo.updateProject(id, body);
+        if (!updated)
+            throw new HttpError(404, 'project not found');
+        return updated;
+    });
+    app.delete('/api/projects/:id', async (req) => {
+        const { id } = req.params;
+        if (!repo.getProject(id))
+            throw new HttpError(404, 'project not found');
+        repo.deleteProject(id);
+        return { ok: true };
+    });
+    // Dependency graph across the project's documents (SPEC-05)
+    app.get('/api/projects/:id/graph', async (req) => {
+        const { id } = req.params;
+        if (!repo.getProject(id))
+            throw new HttpError(404, 'project not found');
+        const docs = repo.listDocuments(id);
+        return {
+            nodes: docs.map((d) => ({
+                id: d.id,
+                type: d.type,
+                title: d.title,
+                status: d.status,
+                contextStale: d.context_stale === 1,
+            })),
+            edges: docs
+                .filter((d) => d.parent_document_id)
+                .map((d) => ({ from: d.parent_document_id, to: d.id })),
+        };
+    });
+    // Example plan for first-run onboarding: a sample chain with open suggestions
+    // so the accept/reject grammar can be practiced on real UI (SYSTEM.md §4).
+    app.post('/api/sample', async () => {
+        const existing = repo.listProjects().find((p) => p.name === SAMPLE_NAME);
+        if (existing) {
+            const docs = repo.listDocuments(existing.id);
+            return { project: existing, documentId: docs[0]?.id ?? null, created: false };
+        }
+        const project = repo.createProject(SAMPLE_NAME, '팀 지표를 매주 월요일 슬랙으로 요약');
+        const prd = repo.createDocument({ projectId: project.id, type: 'prd', title: '제품 요구사항' });
+        repo.createSection(prd.id, '문제 정의', '팀 지표가 여러 대시보드에 흩어져 있어 주간 회의 준비에 매번 30분 이상 쓴다. 리더가 손으로 숫자를 모으는 동안 해석은 뒷전이 된다.');
+        repo.createSection(prd.id, '목표', '매주 월요일 09:00, 지난주 핵심 지표 요약이 슬랙 채널에 자동 게시된다. 준비 시간 30분을 0분으로.');
+        const scope = repo.createSection(prd.id, '범위', '1차 범위는 슬랙 게시 봇 하나. 지표 소스는 스프레드시트 1개로 시작한다.');
+        repo.createSection(prd.id, '지표 이상 감지', '전주 대비 20% 이상 변동한 지표는 요약 상단에 따로 표시한다.', undefined, 'proposed');
+        repo.createSuggestion({
+            documentId: prd.id,
+            kind: 'add',
+            title: '이상 감지 섹션 추가',
+            body: '인터뷰에서 "숫자보다 변화를 놓치는 게 무섭다"고 답했습니다. 급변 지표를 상단에 올리는 규칙을 제안합니다.',
+            quoteAfter: '전주 대비 20% 이상 변동한 지표는 요약 상단에 따로 표시한다.',
+            source: 'Q4',
+        });
+        repo.createSuggestion({
+            documentId: prd.id,
+            sectionId: scope.id,
+            kind: 'revise',
+            title: '범위에 제외 항목 명시',
+            body: '범위 섹션에 "하지 않는 것"이 없으면 스코프가 새기 쉽습니다. 대시보드 UI는 만들지 않는다는 한 줄을 제안합니다.',
+            quoteBefore: '1차 범위는 슬랙 게시 봇 하나. 지표 소스는 스프레드시트 1개로 시작한다.',
+            quoteAfter: '1차 범위는 슬랙 게시 봇 하나. 지표 소스는 스프레드시트 1개로 시작하며, 별도 대시보드 UI는 만들지 않는다.',
+            source: 'PRD §1',
+        });
+        repo.createSuggestion({
+            documentId: prd.id,
+            kind: 'question',
+            title: '누락 확인',
+            body: '요약을 받는 채널이 팀 공개 채널인가요, 리더 전용인가요? 답에 따라 지표 민감도 처리가 갈립니다.',
+            source: 'PRD §2',
+        });
+        return { project, documentId: prd.id, created: true };
+    });
+}
+const SAMPLE_NAME = '예시: 주간 리포트 봇';