tycono 0.1.64 → 0.1.66

package/src/api/src/engine/runners/types.ts

@@ -37,6 +37,8 @@ export interface RunnerConfig {
   jobId?: string;
   teamStatus?: TeamStatus;
   attachments?: ImageAttachment[];
+  /** Selective dispatch scope — only these roles can be dispatched to */
+  targetRoles?: string[];
 }
 
 /* ─── Callbacks ───────────────────────────────── */

package/src/api/src/engine/tools/executor.ts

@@ -4,6 +4,7 @@ import { glob } from 'glob';
 import type { ToolCall, ToolResult } from '../llm-adapter.js';
 import { validateWrite, validateRead } from '../authority-validator.js';
 import type { OrgTree } from '../org-tree.js';
+import { buildKnowledgeGateWarning } from '../knowledge-gate.js';
 
 /* ─── Types ──────────────────────────────────── */
 
@@ -219,12 +220,9 @@ function writeFile(
 
   let result = `File written: ${filePath} (${content.length} chars)`;
 
-  // AKB Level 0 hint: 새 .md 파일 생성 시 (journal 제외)
+  // Knowledge Gate: 새 .md 파일 생성 시 자동 검색 + 경고 (journal 제외)
   if (isNewFile && filePath.endsWith('.md') && !filePath.includes('journal/')) {
-    result += '\n\n[AKB] 새 .md 파일입니다. 확인: '
-      + '(1) search_files로 기존 문서를 검색했는가? '
-      + '(2) 관련 Hub에 등록했는가? '
-      + '(3) cross-link를 추가했는가?';
+    result += buildKnowledgeGateWarning(companyRoot, filePath, content);
   }
 
   return { tool_use_id: id, content: result };

package/src/api/src/routes/active-sessions.ts

@@ -0,0 +1,143 @@
+/**
+ * active-sessions.ts — Active session visibility API
+ *
+ * Exposes session + port + worktree state for both UI and AI agents.
+ * All sessions sharing the same tycono server origin can query this.
+ */
+import { Router } from 'express';
+import { portRegistry } from '../services/port-registry.js';
+import { jobManager } from '../services/job-manager.js';
+
+export const activeSessionsRouter = Router();
+
+/**
+ * GET /api/active-sessions
+ * Returns all active sessions with port + worktree info.
+ * Used by both the web UI and AI agents (curl).
+ */
+activeSessionsRouter.get('/', (_req, res) => {
+  const sessions = portRegistry.getAll();
+
+  // Enrich with job info where available
+  const enriched = sessions.map(s => {
+    const job = jobManager.getJobInfo(s.sessionId);
+    return {
+      ...s,
+      jobStatus: job?.status ?? null,
+      roleName: job?.roleId ?? s.roleId,
+      alive: s.pid ? isAlive(s.pid) : null,
+    };
+  });
+
+  res.json({
+    sessions: enriched,
+    summary: portRegistry.getSummary(),
+  });
+});
+
+/**
+ * GET /api/active-sessions/:id
+ * Get detailed info for a specific session.
+ */
+activeSessionsRouter.get('/:id', (req, res) => {
+  const session = portRegistry.get(req.params.id);
+  if (!session) {
+    res.status(404).json({ error: 'Session not found' });
+    return;
+  }
+
+  const job = jobManager.getJobInfo(session.sessionId);
+
+  res.json({
+    ...session,
+    jobStatus: job?.status ?? null,
+    roleName: job?.roleId ?? session.roleId,
+    alive: session.pid ? isAlive(session.pid) : null,
+    job: job ?? null,
+  });
+});
+
+/**
+ * DELETE /api/active-sessions/:id
+ * Stop a session — release ports + clean up.
+ */
+activeSessionsRouter.delete('/:id', (req, res) => {
+  const sessionId = req.params.id;
+  const session = portRegistry.get(sessionId);
+
+  if (!session) {
+    res.status(404).json({ error: 'Session not found' });
+    return;
+  }
+
+  // Try to abort the job if running
+  jobManager.abortJob(sessionId);
+
+  // Release ports
+  portRegistry.release(sessionId);
+
+  res.json({ ok: true, released: session.ports });
+});
+
+/**
+ * POST /api/active-sessions/cleanup
+ * Clean up all dead sessions (PID gone).
+ */
+activeSessionsRouter.post('/cleanup', (_req, res) => {
+  const result = portRegistry.cleanup();
+  res.json({
+    cleaned: result.cleaned.length,
+    remaining: result.remaining.length,
+    sessions: result.cleaned.map(s => ({
+      sessionId: s.sessionId,
+      roleId: s.roleId,
+      ports: s.ports,
+    })),
+  });
+});
+
+/**
+ * POST /api/active-sessions/register
+ * Manually register a session (for external Claude Code sessions).
+ */
+activeSessionsRouter.post('/register', async (req, res) => {
+  const { sessionId, roleId, task, pid, worktreePath } = req.body;
+
+  if (!sessionId || !roleId) {
+    res.status(400).json({ error: 'sessionId and roleId are required' });
+    return;
+  }
+
+  // Check if already registered
+  const existing = portRegistry.get(sessionId);
+  if (existing) {
+    res.json({ ok: true, ports: existing.ports, existing: true });
+    return;
+  }
+
+  const ports = await portRegistry.allocate(
+    sessionId,
+    roleId,
+    task || 'Manual session',
+  );
+
+  if (pid || worktreePath) {
+    portRegistry.update(sessionId, {
+      pid: pid ?? undefined,
+      worktreePath: worktreePath ?? undefined,
+    });
+  }
+
+  res.json({ ok: true, ports, existing: false });
+});
+
+/* ─── Helpers ────────────────────────────── */
+
+function isAlive(pid: number): boolean {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}

package/src/api/src/routes/coins.ts

@@ -0,0 +1,137 @@
+import { Router, Request, Response, NextFunction } from 'express';
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { COMPANY_ROOT } from '../services/file-reader.js';
+
+export const coinsRouter = Router();
+
+/* ── Types ── */
+
+interface CoinTransaction {
+  ts: string;
+  amount: number;
+  reason: string;
+  ref?: string; // questId, jobId, etc.
+}
+
+interface CoinsData {
+  balance: number;
+  totalEarned: number;
+  totalSpent: number;
+  transactions: CoinTransaction[];
+}
+
+/* ── Persistence ── */
+
+const COINS_FILE = () => join(COMPANY_ROOT, '.tycono', 'coins.json');
+
+const DEFAULT_DATA: CoinsData = {
+  balance: 0,
+  totalEarned: 0,
+  totalSpent: 0,
+  transactions: [],
+};
+
+function readCoins(): CoinsData {
+  try {
+    if (existsSync(COINS_FILE())) {
+      return JSON.parse(readFileSync(COINS_FILE(), 'utf-8'));
+    }
+  } catch { /* use defaults */ }
+  return { ...DEFAULT_DATA, transactions: [] };
+}
+
+function writeCoins(data: CoinsData) {
+  mkdirSync(join(COMPANY_ROOT, '.tycono'), { recursive: true });
+  writeFileSync(COINS_FILE(), JSON.stringify(data, null, 2) + '\n');
+}
+
+/* ── Routes ── */
+
+// GET /api/coins — current balance + summary
+coinsRouter.get('/', (_req: Request, res: Response, next: NextFunction) => {
+  try {
+    res.json(readCoins());
+  } catch (err) { next(err); }
+});
+
+// POST /api/coins/earn — add coins
+coinsRouter.post('/earn', (req: Request, res: Response, next: NextFunction) => {
+  try {
+    const { amount, reason, ref } = req.body;
+    if (typeof amount !== 'number' || amount <= 0) {
+      res.status(400).json({ error: 'amount must be a positive number' });
+      return;
+    }
+    const data = readCoins();
+    // Idempotency: skip if same ref already earned (prevents double quest rewards)
+    if (ref && data.transactions.some(t => t.ref === ref && t.amount > 0)) {
+      res.json({ ok: true, balance: data.balance, skipped: true });
+      return;
+    }
+    const tx: CoinTransaction = {
+      ts: new Date().toISOString(),
+      amount,
+      reason: reason || 'earn',
+      ref,
+    };
+    data.balance += amount;
+    data.totalEarned += amount;
+    data.transactions.push(tx);
+    writeCoins(data);
+    res.json({ ok: true, balance: data.balance, transaction: tx });
+  } catch (err) { next(err); }
+});
+
+// POST /api/coins/spend — deduct coins
+coinsRouter.post('/spend', (req: Request, res: Response, next: NextFunction) => {
+  try {
+    const { amount, reason, ref } = req.body;
+    if (typeof amount !== 'number' || amount <= 0) {
+      res.status(400).json({ error: 'amount must be a positive number' });
+      return;
+    }
+    const data = readCoins();
+    if (data.balance < amount) {
+      res.status(400).json({ error: 'insufficient balance', balance: data.balance, required: amount });
+      return;
+    }
+    const tx: CoinTransaction = {
+      ts: new Date().toISOString(),
+      amount: -amount,
+      reason: reason || 'spend',
+      ref,
+    };
+    data.balance -= amount;
+    data.totalSpent += amount;
+    data.transactions.push(tx);
+    writeCoins(data);
+    res.json({ ok: true, balance: data.balance, transaction: tx });
+  } catch (err) { next(err); }
+});
+
+// POST /api/coins/migrate — initial coin grant for existing users
+coinsRouter.post('/migrate', (req: Request, res: Response, next: NextFunction) => {
+  try {
+    const data = readCoins();
+    // Only migrate once
+    if (data.totalEarned > 0) {
+      res.json({ ok: true, skipped: true, balance: data.balance });
+      return;
+    }
+    const { completedQuests = 0 } = req.body;
+    const grantAmount = completedQuests > 0 ? completedQuests * 2000 : 5000;
+    const reason = completedQuests > 0 ? `migration: ${completedQuests} quests × 2,000` : 'welcome bonus';
+    const tx: CoinTransaction = {
+      ts: new Date().toISOString(),
+      amount: grantAmount,
+      reason,
+      ref: 'migration',
+    };
+    data.balance = grantAmount;
+    data.totalEarned = grantAmount;
+    data.transactions.push(tx);
+    writeCoins(data);
+    res.json({ ok: true, balance: data.balance, granted: grantAmount, reason });
+  } catch (err) { next(err); }
+});

package/src/api/src/routes/execute.ts

@@ -7,6 +7,7 @@ import { buildOrgTree, canDispatchTo, getSubordinates } from '../engine/org-tree
 import { createRunner, type RunnerResult } from '../engine/runners/index.js';
 import {
   getSession,
+  createSession,
   addMessage,
   updateMessage,
   type Message,
@@ -133,7 +134,7 @@ function handleStartJob(body: Record<string, unknown>, res: ServerResponse): voi
   const targetRole = (body.targetRole as string) || 'cto';
   const parentJobId = body.parentJobId as string | undefined;
 
-  // Wave shorthand — broadcast to ALL C-level direct reports
+  // Wave shorthand — broadcast to C-level direct reports (optionally filtered)
   if (type === 'wave') {
     if (!directive) {
       jsonResponse(res, 400, { error: 'directive is required for wave jobs' });
@@ -141,26 +142,74 @@ function handleStartJob(body: Record<string, unknown>, res: ServerResponse): voi
     }
 
     const orgTree = buildOrgTree(COMPANY_ROOT);
-    const cLevelRoles = getSubordinates(orgTree, 'ceo');
+    let cLevelRoles = getSubordinates(orgTree, 'ceo');
+
+    // Selective dispatch: filter by targetRoles if provided
+    const targetRoles = body.targetRoles as string[] | undefined;
+    if (targetRoles && Array.isArray(targetRoles) && targetRoles.length > 0) {
+      const allowed = new Set(targetRoles);
+      cLevelRoles = cLevelRoles.filter(r => allowed.has(r));
+    }
 
     if (cLevelRoles.length === 0) {
       jsonResponse(res, 400, { error: 'No C-level roles found to dispatch wave.' });
       return;
     }
 
+    // Resolve full targetRoles scope for re-dispatch filtering
+    // Include both the C-level roles AND any sub-roles from targetRoles
+    const fullTargetScope = targetRoles && targetRoles.length > 0 ? targetRoles : undefined;
+
+    // D-014: Create Wave meta + Sessions for each target role
+    const waveId = `wave-${Date.now()}`;
     const jobIds: string[] = [];
+    const sessionIds: string[] = [];
+
     for (const cRole of cLevelRoles) {
+      // Create a Session for this role (D-014: Wave = Session batch creation)
+      const session = createSession(cRole, {
+        mode: 'do',
+        source: 'wave',
+        waveId,
+      });
+      sessionIds.push(session.id);
+
+      // Add CEO directive as the first message in the session
+      const ceoMsg: Message = {
+        id: `msg-${Date.now()}-ceo-${cRole}`,
+        from: 'ceo',
+        content: directive,
+        type: 'directive',
+        status: 'done',
+        timestamp: new Date().toISOString(),
+      };
+      addMessage(session.id, ceoMsg);
+
       const job = jobManager.startJob({
         type: 'wave',
         roleId: cRole,
         task: `[CEO Wave] ${directive}`,
         sourceRole: 'ceo',
         parentJobId,
+        targetRoles: fullTargetScope,
+        sessionId: session.id,       // D-014: link job to session
       });
       jobIds.push(job.id);
+
+      // Add a role message (will be updated as execution progresses)
+      const roleMsg: Message = {
+        id: `msg-${Date.now() + 1}-role-${cRole}`,
+        from: 'role',
+        content: '',
+        type: 'conversation',
+        status: 'streaming',
+        timestamp: new Date().toISOString(),
+        jobId: job.id,
+      };
+      addMessage(session.id, roleMsg, true);
     }
 
-    jsonResponse(res, 200, { jobIds });
+    jsonResponse(res, 200, { jobIds, waveId, sessionIds });
     return;
   }
 
@@ -176,16 +225,53 @@ function handleStartJob(body: Record<string, unknown>, res: ServerResponse): voi
     return;
   }
 
+  // D-014: Create/find session for CEO assigns (not for dispatch child jobs)
+  let sessionId: string | undefined;
+  if (sourceRole === 'ceo' && !parentJobId) {
+    const session = createSession(roleId, {
+      mode: readOnly ? 'talk' : 'do',
+      source: 'dispatch',
+    });
+    sessionId = session.id;
+
+    // Add CEO message
+    const ceoMsg: Message = {
+      id: `msg-${Date.now()}-ceo`,
+      from: 'ceo',
+      content: task,
+      type: readOnly ? 'conversation' : 'directive',
+      status: 'done',
+      timestamp: new Date().toISOString(),
+    };
+    addMessage(session.id, ceoMsg);
+  }
+
   const job = jobManager.startJob({
-    type: 'assign',
+    type: readOnly ? 'consult' : 'assign',
     roleId,
     task,
     sourceRole,
     readOnly,
     parentJobId,
+    sessionId,
   });
 
-  jsonResponse(res, 200, { jobId: job.id });
+  // D-014: Add role message linked to job
+  if (sessionId) {
+    const roleMsg: Message = {
+      id: `msg-${Date.now() + 1}-role`,
+      from: 'role',
+      content: '',
+      type: 'conversation',
+      status: 'streaming',
+      timestamp: new Date().toISOString(),
+      jobId: job.id,
+      readOnly: readOnly || undefined,
+    };
+    addMessage(sessionId, roleMsg, true);
+  }
+
+  jsonResponse(res, 200, { jobId: job.id, ...(sessionId && { sessionId }) });
 }
 
 /* ─── GET /api/jobs ──────────────────────── */
@@ -296,7 +382,7 @@ function handleReplyToJob(jobId: string, body: Record<string, unknown>, res: Ser
 
   const newJob = jobManager.replyToJob(jobId, message, responderRole);
   if (!newJob) {
-    jsonResponse(res, 400, { error: 'Job not found or not awaiting input' });
+    jsonResponse(res, 400, { error: 'Job not found or not in a replyable state' });
     return;
   }
 
@@ -308,60 +394,56 @@ function handleReplyToJob(jobId: string, body: Record<string, unknown>, res: Ser
 function handleSaveWave(body: Record<string, unknown>, res: ServerResponse): void {
   const directive = body.directive as string;
   const jobIds = body.jobIds as string[];
+  const sessionIds = body.sessionIds as string[] | undefined;
+  const waveId = body.waveId as string | undefined;
 
   if (!directive || !jobIds || jobIds.length === 0) {
     jsonResponse(res, 400, { error: 'directive and jobIds are required' });
     return;
   }
 
-  // Build wave summary from job streams
   const now = new Date();
   const dateStr = now.toISOString().slice(0, 10);
-  const timeStr = now.toTimeString().slice(0, 5);
-  const lines: string[] = [
-    `# Wave — ${dateStr} ${timeStr}`,
-    '',
-    `> ${directive}`,
-    '',
-  ];
+
+  // Structured data for JSON replay
+  interface WaveRoleData {
+    roleId: string;
+    roleName: string;
+    jobId: string;
+    status: string;
+    events: ReturnType<typeof ActivityStream.readAll>;
+    childJobs: Array<{ roleId: string; roleName: string; jobId: string; status: string; events: ReturnType<typeof ActivityStream.readAll> }>;
+  }
+  const rolesData: WaveRoleData[] = [];
 
   for (const jobId of jobIds) {
     const events = ActivityStream.readAll(jobId);
     const startEvent = events.find(e => e.type === 'job:start');
     const roleId = startEvent?.roleId ?? 'unknown';
-    const doneEvent = events.find(e => e.type === 'job:done' || e.type === 'job:awaiting_input');
-
-    lines.push(`## ${roleId.toUpperCase()}`);
-    lines.push('');
+    const roleName = (startEvent?.data?.roleName as string) ?? roleId;
+    const doneEvent = events.find(e => e.type === 'job:done' || e.type === 'job:awaiting_input' || e.type === 'job:error');
+    const status = doneEvent?.type === 'job:done' ? 'done' : doneEvent?.type === 'job:error' ? 'error' : doneEvent?.type === 'job:awaiting_input' ? 'awaiting_input' : 'unknown';
 
-    // Collect text output
-    const textParts: string[] = [];
+    // Collect child jobs (dispatched sub-roles)
+    const childJobs: WaveRoleData['childJobs'] = [];
     for (const e of events) {
-      if (e.type === 'text' && typeof e.data.text === 'string') {
-        textParts.push(e.data.text);
+      if (e.type === 'dispatch:start' && e.data.childJobId) {
+        const childJobId = e.data.childJobId as string;
+        const targetRoleId = (e.data.targetRoleId as string) ?? 'unknown';
+        const childEvents = ActivityStream.readAll(childJobId);
+        const childDone = childEvents.find(ce => ce.type === 'job:done' || ce.type === 'job:error' || ce.type === 'job:awaiting_input');
+        const childStatus = childDone?.type === 'job:done' ? 'done' : childDone?.type === 'job:error' ? 'error' : 'unknown';
+        childJobs.push({
+          roleId: targetRoleId,
+          roleName: (childEvents.find(ce => ce.type === 'job:start')?.data?.roleName as string) ?? targetRoleId,
+          jobId: childJobId,
+          status: childStatus,
+          events: childEvents,
+        });
       }
     }
-    const fullText = textParts.join('');
-    // Take last 1500 chars as summary
-    const summary = fullText.length > 1500
-      ? '...' + fullText.slice(-1500)
-      : fullText;
-
-    if (summary.trim()) {
-      lines.push(summary.trim());
-    } else {
-      lines.push('(No text output)');
-    }
 
-    if (doneEvent) {
-      const turns = doneEvent.data.turns as number ?? 0;
-      const tools = doneEvent.data.toolCalls as number ?? 0;
-      lines.push('');
-      lines.push(`*${turns} turns, ${tools} tool calls*`);
-    }
-    lines.push('');
-    lines.push('---');
-    lines.push('');
+    rolesData.push({ roleId, roleName, jobId, status, events, childJobs });
   }
 
   // Write to operations/waves/
@@ -369,11 +451,23 @@ function handleSaveWave(body: Record<string, unknown>, res: ServerResponse): voi
   if (!fs.existsSync(wavesDir)) {
     fs.mkdirSync(wavesDir, { recursive: true });
   }
-  const filename = `wave-${dateStr}-${Date.now()}.md`;
-  const filePath = path.join(wavesDir, filename);
-  fs.writeFileSync(filePath, lines.join('\n'), 'utf-8');
+  const hhmmss = now.toTimeString().slice(0, 8).replace(/:/g, '');
+  const baseName = `${dateStr.replace(/-/g, '')}-${hhmmss}-wave`;
+  const jsonPath = path.join(wavesDir, `${baseName}.json`);
+
+  const waveJson = {
+    id: baseName,
+    directive,
+    startedAt: now.toISOString(),
+    duration: 0, // Could be computed from events
+    roles: rolesData,
+    // D-014: Session references for follow-up
+    ...(waveId && { waveId }),
+    ...(sessionIds && sessionIds.length > 0 && { sessionIds }),
+  };
+  fs.writeFileSync(jsonPath, JSON.stringify(waveJson, null, 2), 'utf-8');
 
-  jsonResponse(res, 200, { ok: true, path: `operations/waves/${filename}` });
+  jsonResponse(res, 200, { ok: true, path: `operations/waves/${baseName}.json` });
 }
 
 /* ═══════════════════════════════════════════════
@@ -543,13 +637,23 @@ function handleWave(body: Record<string, unknown>, req: IncomingMessage, res: Se
   }
 
   const orgTree = buildOrgTree(COMPANY_ROOT);
-  const cLevelRoles = getSubordinates(orgTree, 'ceo');
+  let cLevelRoles = getSubordinates(orgTree, 'ceo');
+
+  // Selective dispatch: filter by targetRoles if provided
+  const targetRoles = body.targetRoles as string[] | undefined;
+  if (targetRoles && Array.isArray(targetRoles) && targetRoles.length > 0) {
+    const allowed = new Set(targetRoles);
+    cLevelRoles = cLevelRoles.filter(r => allowed.has(r));
+  }
 
   if (cLevelRoles.length === 0) {
     jsonResponse(res, 400, { error: 'No C-level roles found to dispatch wave.' });
     return;
   }
 
+  // Resolve full targetRoles scope for re-dispatch filtering
+  const fullTargetScope = targetRoles && targetRoles.length > 0 ? targetRoles : undefined;
+
   // Start a job for EACH C-level role
   const jobs: Job[] = [];
   for (const cRole of cLevelRoles) {
@@ -558,6 +662,7 @@ function handleWave(body: Record<string, unknown>, req: IncomingMessage, res: Se
       roleId: cRole,
       task: `[CEO Wave] ${directive}`,
       sourceRole: 'ceo',
+      targetRoles: fullTargetScope,
     });
     jobs.push(job);
   }
@@ -909,7 +1014,12 @@ function handleSessionMessage(
     .then((result: RunnerResult) => {
       cleanupSSELifecycle();
       cleanupChildSubscriptions();
-      updateMessage(sessionId, roleMsg.id, { content: roleMsg.content, status: 'done' });
+      updateMessage(sessionId, roleMsg.id, {
+        content: roleMsg.content,
+        status: 'done',
+        turns: result.turns,
+        tokens: result.totalTokens,
+      });
       roleStatus.set(roleId, 'idle');
       completeActivity(roleId);
       for (const d of result.dispatches) {

package/src/api/src/routes/knowledge.ts

@@ -10,6 +10,7 @@ import path from 'node:path';
 import matter from 'gray-matter';
 import { glob } from 'glob';
 import { COMPANY_ROOT } from '../services/file-reader.js';
+import { detectDecay, searchRelatedDocs, extractKeywords } from '../engine/knowledge-gate.js';
 
 export const knowledgeRouter = Router();
 
@@ -144,6 +145,35 @@ knowledgeRouter.get('/', (_req: Request, res: Response, next: NextFunction) => {
   }
 });
 
+/* ─── Knowledge Health endpoint ──────────────────── */
+
+knowledgeRouter.get('/health', (_req: Request, res: Response, next: NextFunction) => {
+  try {
+    const report = detectDecay(companyRoot());
+    res.json(report);
+  } catch (err) {
+    next(err);
+  }
+});
+
+/* ─── Related docs search endpoint ──────────────── */
+
+knowledgeRouter.get('/related', (req: Request, res: Response, next: NextFunction) => {
+  try {
+    const query = String(req.query.q ?? '');
+    if (!query) {
+      res.status(400).json({ error: 'q parameter required' });
+      return;
+    }
+
+    const keywords = extractKeywords(query);
+    const docs = searchRelatedDocs(companyRoot(), keywords);
+    res.json({ keywords, docs });
+  } catch (err) {
+    next(err);
+  }
+});
+
 /* ─── Single document endpoint ────────────────────── */
 
 /* ─── Create document endpoint ───────────────────── */