cuelo 0.10.1 → 0.10.2

package/.next/trace-build

@@ -1 +1 @@
-[{"name":"run-webpack","duration":112423190,"timestamp":700170,"id":14,"parentId":1,"tags":{},"startTime":1791473713913,"traceId":"3606727d2701de14"},{"name":"run-typescript","duration":20687094,"timestamp":113483877,"id":11084,"parentId":1,"tags":{},"startTime":1791473826697,"traceId":"3606727d2701de14"},{"name":"static-check","duration":4251042,"timestamp":134266247,"id":11087,"parentId":1,"tags":{},"startTime":1791473847479,"traceId":"3606727d2701de14"},{"name":"static-generation","duration":12640866,"timestamp":138637262,"id":11259,"parentId":1,"tags":{},"startTime":1791473851850,"traceId":"3606727d2701de14"},{"name":"collect-build-traces","duration":21550937,"timestamp":138595291,"id":11256,"parentId":1,"tags":{},"startTime":1791473851808,"traceId":"3606727d2701de14"},{"name":"telemetry-flush","duration":89,"timestamp":160150808,"id":11268,"parentId":1,"tags":{},"startTime":1791473873364,"traceId":"3606727d2701de14"},{"name":"next-build","duration":159572212,"timestamp":578707,"id":1,"tags":{"buildMode":"default","version":"16.2.12","bundler":"webpack","has-custom-webpack-config":"true","use-build-worker":"false"},"startTime":1791473713792,"traceId":"3606727d2701de14"}]
+[{"name":"run-webpack","duration":114018786,"timestamp":687805,"id":14,"parentId":1,"tags":{},"startTime":1791507921870,"traceId":"6c75260e77b7370d"},{"name":"run-typescript","duration":24733849,"timestamp":115113546,"id":11084,"parentId":1,"tags":{},"startTime":1791508036296,"traceId":"6c75260e77b7370d"},{"name":"static-check","duration":4561356,"timestamp":139975975,"id":11087,"parentId":1,"tags":{},"startTime":1791508061159,"traceId":"6c75260e77b7370d"},{"name":"static-generation","duration":12317561,"timestamp":144649546,"id":11259,"parentId":1,"tags":{},"startTime":1791508065832,"traceId":"6c75260e77b7370d"},{"name":"collect-build-traces","duration":21852595,"timestamp":144608304,"id":11256,"parentId":1,"tags":{},"startTime":1791508065791,"traceId":"6c75260e77b7370d"},{"name":"telemetry-flush","duration":109,"timestamp":166472512,"id":11268,"parentId":1,"tags":{},"startTime":1791508087655,"traceId":"6c75260e77b7370d"},{"name":"next-build","duration":165897246,"timestamp":575399,"id":1,"tags":{"buildMode":"default","version":"16.2.12","bundler":"webpack","has-custom-webpack-config":"true","use-build-worker":"false"},"startTime":1791507921758,"traceId":"6c75260e77b7370d"}]

package/README.md

@@ -16,7 +16,7 @@ Use the same `~/.omp/agent` sessions, credentials and model configuration from t
 
 **한국어:** CUELO는 omp(oh-my-pi)를 위한 오픈소스 AI 코딩 에이전트 작업 공간이자 하네스입니다. 웹 앱은 omp SDK를 서버 안에서 실행하고, `omp` CLI와 같은 `~/.omp/agent` 디렉터리를 씁니다. 터미널에서 하던 세션을 브라우저에서 이어 가고, 다시 터미널로 돌아가도 기록·계정·모델 설정을 공유합니다.
 
-내장 OMP 코어는 **18.8.5**입니다. 별도로 설치한 `omp` CLI의 버전은 웹 업데이트와 독립적이며, 앱에 포함된 CLI를 `omp` 명령으로 사용하는 설치에서는 웹과 같은 코어를 사용합니다.
+내장 OMP 코어는 **18.8.6**입니다. 별도로 설치한 `omp` CLI의 버전은 웹 업데이트와 독립적이며, 앱에 포함된 CLI를 `omp` 명령으로 사용하는 설치에서는 웹과 같은 코어를 사용합니다.
 
 CUELO의 목적은 작업 중 확인한 실패와 막힘을 기억·작업 규칙·실행 절차에 반영해, 사람이 같은 문제를 다시 지적하지 않아도 다음 작업에서 실수를 줄이는 것입니다. 원인을 확인하고 필요한 부분만 바꾸며, 다음 작업에서 적용과 효과를 확인하는 것까지를 지향합니다. 기록을 저장했다는 이유만으로 자동 개선이 끝났다고 보지는 않습니다.
 

package/Tools/CUELO_Setup/files/native-runtime-patch.js

@@ -9,9 +9,9 @@ const MEMORY_RE = /(const phase1Model = await resolveMemoryModel\(\{[^}]*?fallba
 const MEMORY_DONE = /const phase1Model = await resolveMemoryModel\(\{[^}]*?fallbackRole: "smol"/;
 const EXPECTED = {
     name: 'cuelo',
-    version: '0.10.1',
+    version: '0.10.2',
     distribution: 'cuelo',
-    coreVersion: '18.8.5',
+    coreVersion: '18.8.6',
 };
 
 // OMP core 18.4.12 `src/sdk.ts`: session-scoped AsyncJobManager for a process
@@ -177,7 +177,7 @@ function readNativePackage(target) {
         throw new Error(`unexpected native package ${packageJson.name}@${packageJson.version}`);
     }
     if (!build || build.distribution !== EXPECTED.distribution || build.coreVersion !== EXPECTED.coreVersion) {
-        throw new Error('native cueloBuild metadata does not match cuelo / core 18.8.5');
+        throw new Error('native cueloBuild metadata does not match cuelo / core 18.8.6');
     }
     return packageJson;
 }

package/Tools/OMP_Global_Config/agent/RULES.md

@@ -59,6 +59,10 @@
 - 여러 파일을 훑거나 문서·README·저장소 구조를 조사할 때는 먼저 `skim`에 질문한다. 허용 텍스트 파일
   내용은 Google(Gemini), 그 호출이 실패해 한 번 대체되면 B.AI(DeepSeek)로도 전송된다.
   비밀 자료를 대상으로 삼지 말고, 수정할 정확한 줄은 `read`로 확인한다.
+- 문서 초안(md·csv·Excel·Word·PDF 보고서·표)이 필요하면 Main·Maker 모두 먼저 `draft`로 쓴다. Gemini가
+  작성해 cwd 안에 저장하고, 실패하면 DeepSeek로 한 번 대체한다(참고 텍스트는 Google 또는 B.AI로 전송).
+  만들어진 파일은 직접 열어 검토한 뒤 쓴다. 코드·설정·규칙·`HANDOFF.md`·작업 기록·정확한 줄 수정은 초안이
+  아니므로 `edit`/`write`를 쓴다. Gemini 할당량은 같은 Antigravity 계정의 vision·skim과 공유한다.
 - **브라우저는 relay가 기본값이다.** `browser.open`에 `app: { relay: false }`를 빼면 관리형 headless가
   아니라 **사용자의 실제 브라우저**에 탭이 열린다. 닫을 때는 `browser.close({ name })`로 자기 탭만
   닫고 `all`·`kill`·`app.path`는 쓰지 않는다 — 사용자 창까지 닫히거나 기존 프로세스에 붙는다.

package/Tools/OMP_Global_Config/agent/agents/maker.md

@@ -3,10 +3,10 @@ name: maker
 description: Delegated end-to-end implementation agent that investigates, edits, repairs, validates its own slice, and verifies the actual surface it changed.
 model: "@implSonnet"
 thinking-level: auto
-tools: [read, bash, edit, write, grep, glob, skim, lsp, eval, generate_image, ast_grep, ast_edit, debug, todo, web_search, checkpoint]
+tools: [read, bash, edit, write, grep, glob, skim, draft, lsp, eval, generate_image, ast_grep, ast_edit, debug, todo, web_search, checkpoint]
 ---
 
-<!-- omp-global-config:generated source-hash=e79273fcc4b3
+<!-- omp-global-config:generated source-hash=29515cbfea01
   이 파일은 patches/build-agents.mjs 가 만든 빌드 산출물이다. 직접 수정하지 마라.
   고칠 곳: agent/sop/maker.md · agent/sop/_writer.md · agent/sop/_common.md
   재생성: node patches/build-agents.mjs   검사: node patches/build-agents.mjs --check
@@ -26,6 +26,12 @@ is yours end to end.
   outside the brief boundary, to production or external processes, or invoking `write_memory` is
   allowed only when the brief names the exact target and action and applicable user approval exists.
 - Use `web_search` to discover current external information, then use `read` on the primary source.
+- When the slice needs a document draft (Markdown, CSV, Excel, Word, PDF report or table), write it
+  with `draft(instruction, output, paths?)` first: Gemini Flash writes it (DeepSeek once on
+  failure; reference text goes to Google or B.AI) and the tool saves the file inside the cwd.
+  Open and review the produced file before you use or hand it over. Code, configuration, rules,
+  `HANDOFF.md`, your own `doc/history` record, and exact-line edits are not drafts; keep using
+  `edit`/`write` for them.
 - Use `todo` only when the work has three or more steps. If you invoke `checkpoint`, invoke the
   runtime-paired `rewind` before yielding.
 - In that same first investigation, cross-check the brief itself: does changing the assigned
@@ -260,10 +266,10 @@ is yours end to end.
 
 ## Common Rules
 
-- **Use Korean for the task brief's prose and every user-visible progress or final prose, even when
-  upstream or historical material is English.** Preserve required structural keys/headings,
-  model IDs, code, commands, paths, filenames, API names, and original errors verbatim. Do not
-  create an English or bilingual fallback contract. Hidden reasoning language is not governed.
+- **The task brief and every follow-up instruction from Main are written in English (user decision
+  2026-10-09). Every user-visible progress or final prose you write stays Korean, even though the
+  brief is English.** Preserve required structural keys/headings, model IDs, code, commands, paths,
+  filenames, API names, and original errors verbatim. Hidden reasoning language is not governed.
 - The brief's allowed boundary — the projects, paths, and ownership it names — is absolute. The
   files it points you at are where the investigation starts, not the limit of what you may read
   or change. Inside that boundary you own the direct cause of the assigned problem even when it

package/Tools/OMP_Global_Config/agent/extensions/character-voice.ts

@@ -425,7 +425,7 @@ export function renderCharacterSummonRouting(aliases: CharacterAlias | readonly
     `[CharacterSummon] 사용자가 ${alias}을(를) 인라인으로 호출했다.`,
     `먼저 사용자에게 자연스러운 한국어와 ${alias}의 성격·표현으로 ${target.model}을(를) 호출한다고 짧고 자연스럽게 답한다.`,
     "그 다음 첫 관련 행동은 반드시 task child 호출이어야 한다. Main이 대신 답하거나 다른 도구로 우회하지 않는다.",
-    "task brief의 산문과 child가 사용자 화면에 표시하는 진행·최종 산문은 모두 한국어다. 선택된 character voice를 그대로 따르며, `TASK_GUARD`와 필드명, 필요한 heading, 모델 ID, 코드, 명령, 경로, API, 원본 오류는 원문 그대로 둔다.",
+    "task brief와 후속 지시의 산문은 영어로 쓰고, child가 사용자 화면에 표시하는 진행·최종 산문은 모두 한국어다. 선택된 character voice를 그대로 따르며, `TASK_GUARD`와 필드명, 필요한 heading, 모델 ID, 코드, 명령, 경로, API, 원본 오류는 원문 그대로 둔다.",
     "command guard가 task brief에 선택된 모델과 아래 voice 계약을 넣는다. child는 첫 provider request 전에 그 모델로 세션 한정 전환하고, 이전 voice block을 제거한 뒤 이 block을 effective system prompt에 정확히 한 번 설치한다.",
     renderCharacterVoice(alias),
     "호출된 캐릭터 child의 terminal 발화는 이미 사용자 화면에 표시되는 정본이다. Main은 그 본문을 다시 인용·요약·재집계하지 않고, child가 실패하거나 미완료일 때만 자기 말로 그 상태를 알린다.",
@@ -455,7 +455,7 @@ function renderMultiCharacterSummonRouting(aliases: readonly CharacterAlias[]):
         : "그 다음 첫 관련 행동은 반드시 task child 호출이어야 한다. Main이 대신 답하거나 다른 도구로 우회하지 않는다.",
       "한 번의 task 호출의 tasks[]에 tool-capable 캐릭터마다 task 하나씩을 언급 순서대로 넣는다. 각 task 본문에는 아래 exact marker를 그대로 쓴다. marker가 없거나 pending과 다른 alias이면 command guard가 차단한다. 일반 task를 같은 호출에 섞지 않는다.",
       ...capable.map((alias) => `- ${alias}: \`${summonMarkerFor(alias)}\``),
-      "task brief의 산문과 child가 사용자 화면에 표시하는 진행·최종 산문은 모두 한국어다. `TASK_GUARD`와 필드명, 필요한 heading, 모델 ID, 코드, 명령, 경로, API, 원본 오류는 원문 그대로 둔다.",
+      "task brief와 후속 지시의 산문은 영어로 쓰고, child가 사용자 화면에 표시하는 진행·최종 산문은 모두 한국어다. `TASK_GUARD`와 필드명, 필요한 heading, 모델 ID, 코드, 명령, 경로, API, 원본 오류는 원문 그대로 둔다.",
     );
   }
   for (const alias of webOnly) {
@@ -565,7 +565,7 @@ export function buildCharacterSummonBrief(brief: string, alias: CharacterAlias):
         ? ""
         : ` Anthropic OAuth 계정은 stable storage position ${target.oauthPosition}을 먼저 pin한다.`
     }`,
-    "- 이 task brief의 산문과 사용자 화면에 표시하는 모든 진행·최종 산문은 한국어다. 선택된 character voice를 그대로 따르며, `TASK_GUARD`와 필드명, 필요한 heading, 모델 ID, 코드, 명령, 경로, API, 원본 오류는 원문 그대로 둔다.",
+    "- 이 task brief의 산문은 영어지만, 사용자 화면에 표시하는 모든 진행·최종 산문은 한국어다. 선택된 character voice를 그대로 따르며, `TASK_GUARD`와 필드명, 필요한 heading, 모델 ID, 코드, 명령, 경로, API, 원본 오류는 원문 그대로 둔다.",
     "- 아래 character voice block을 effective system prompt와 최종 provider payload에 정확히 한 번 설치하고, 이전 character voice block은 제거한다. 고정 catchphrase는 만들지 않는다.",
     renderCharacterVoice(alias),
     "- 이 child의 terminal 발화 자체가 사용자 화면에 표시되는 정본이다. Main에게 다시 전달할 요약을 쓰거나 본문 재인용을 요청하지 말고, 원래 과제에 대한 완전한 응답을 직접 끝낸다.",

package/Tools/OMP_Global_Config/agent/extensions/command-guard/index.ts

@@ -2,6 +2,7 @@ import { execFile } from "node:child_process";
 import { resolve } from "node:path";
 
 import { isToolCallEventType, type ExtensionAPI } from "@oh-my-pi/pi-coding-agent";
+import { resolveToCwd } from "@oh-my-pi/pi-coding-agent/tools/path-utils";
 import {
   CHARACTER_TARGETS,
   malformedSummonMarkerReason,
@@ -55,6 +56,20 @@ function eventSessionCwd(ctx: { cwd?: string } | undefined): string {
   return typeof ctx?.cwd === "string" && ctx.cwd ? resolve(ctx.cwd) : process.cwd();
 }
 
+/**
+ * bash 도구의 `cwd` 인자를 코어 bash와 같은 규칙으로 푼다. WSL에서 `E:/x`·`E:\x`는 코어가
+ * `/mnt/e/x`에서 실행하므로, `path.resolve`로 `<세션 cwd>/E:/x`를 만들면 없는 경로의 저장소를
+ * 증명하지 못해 다른 저장소의 git까지 막는다. 첫 판정 전에 명령을 동기적으로 읽어야 하므로 sync다.
+ */
+function bashToolCwd(sessionCwd: string, inputCwd: string): string {
+  try {
+    return resolve(resolveToCwd(inputCwd, sessionCwd));
+  } catch {
+    // 내부 URL 등 코어가 거절한 cwd는 기존 판정으로 넘긴다.
+    return resolve(sessionCwd, inputCwd);
+  }
+}
+
 /**
  * terminal id가 가리키는 현재 미보고 entry key를 await 전에 고정한다. 같은 child 이름을 다시 써도
  * reportOwnedChildren에 exact key를 넘기므로 먼저 끝난 capture가 새 항목을 소비하지 않는다.
@@ -823,7 +838,7 @@ export default function commandGuard(pi: ExtensionAPI): void {
 
     const sessionCwd = eventSessionCwd(ctx);
     const cwd =
-      typeof event.input.cwd === "string" ? resolve(sessionCwd, event.input.cwd) : sessionCwd;
+      typeof event.input.cwd === "string" ? bashToolCwd(sessionCwd, event.input.cwd) : sessionCwd;
     const targetDirectories: string[] = [];
     const collectTarget = (directory: string): boolean => {
       targetDirectories.push(directory);

package/Tools/OMP_Global_Config/agent/extensions/command-guard/powershell-syntax.ts

@@ -18,13 +18,14 @@ const CMDLETS = new Set(
 );
 
 const GUIDANCE_WINDOWS =
-  "PowerShell 로직은 `write`로 .ps1 파일을 만든 뒤 `powershell.exe -NoProfile -ExecutionPolicy Bypass -File C:/절대/슬래시/경로.ps1`로 실행하세요.";
+  "PowerShell 로직은 `write`로 .ps1 파일을 만든 뒤 PowerShell 7 `pwsh -NoProfile -ExecutionPolicy Bypass -File C:/절대/슬래시/경로.ps1`로 실행하세요(7이 없을 때만 `powershell.exe`).";
 
 // WSL의 bash는 진짜 bash라 따옴표·`\$`가 정상 처리되고, Windows 프로그램에는 Windows 경로를 넘겨야 한다.
-// 한글은 BOM 없는 .ps1을 PowerShell 5.1이 CP949로 읽고 stdout도 CP949로 내보내 깨진다(2026-10-07 관측).
+// Linux `pwsh`가 아니라 Windows PowerShell 7(`pwsh.exe`)을 부른다. 5.1은 BOM 없는 .ps1을 CP949로 읽는다.
+// 7도 WSL로 넘기는 stdout은 시스템 코드페이지(CP949)라 한글이 깨진다(2026-10-09 7.6.6에서 관측).
 const GUIDANCE_LINUX =
-  "PowerShell 로직은 `write`로 .ps1 파일을 만든 뒤 `powershell.exe -NoProfile -ExecutionPolicy Bypass -File \"$(wslpath -w /절대/경로.ps1)\"`로 실행하세요. " +
-  "한글이 있으면 .ps1을 UTF-8 BOM으로 저장하고 첫 줄에 `[Console]::OutputEncoding = [Text.UTF8Encoding]::new($false)`를 두세요. " +
+  "PowerShell 로직은 `write`로 .ps1 파일을 만든 뒤 Windows PowerShell 7 `pwsh.exe -NoProfile -ExecutionPolicy Bypass -File \"$(wslpath -w /절대/경로.ps1)\"`로 실행하세요(7이 없을 때만 `powershell.exe`). " +
+  "한글을 출력하면 .ps1 첫 줄(짧은 `-Command`면 본문 맨 앞)에 `[Console]::OutputEncoding = [Text.UTF8Encoding]::new($false)`를 두세요. `powershell.exe`(5.1)로 실행하면 .ps1도 UTF-8 BOM으로 저장해야 합니다. " +
   "짧은 `-Command` 본문은 작은따옴표로 감싸거나 `\\$`로 이스케이프하면 통과합니다.";
 
 function reason(subject: string, platform: NodeJS.Platform): string {

package/Tools/OMP_Global_Config/agent/extensions/draft/markdown.ts

@@ -0,0 +1,226 @@
+// draft의 docx·pdf 변환이 함께 쓰는 Markdown 부분집합 파서.
+// 지원: 제목(#~######), 문단, **굵게**·*기울임*·`코드`·[링크](url), 글머리·번호 목록(들여쓰기 중첩),
+// GFM 표, 펜스 코드 블록, 인용(>), 가로줄. 그 밖의 문법은 글자 그대로 문단에 남는다.
+
+export interface Run { text: string; bold?: boolean; italic?: boolean; code?: boolean; href?: string }
+export interface ListItem { level: number; ordered: boolean; runs: Run[] }
+export type Block =
+  | { kind: "heading"; level: number; runs: Run[] }
+  | { kind: "paragraph"; runs: Run[] }
+  | { kind: "list"; items: ListItem[] }
+  | { kind: "table"; header: Run[][]; rows: Run[][][] }
+  | { kind: "code"; lines: string[] }
+  | { kind: "quote"; runs: Run[] }
+  | { kind: "rule" };
+
+const HEADING = /^ {0,3}(#{1,6})\s+(.*?)\s*#*\s*$/;
+const FENCE = /^ {0,3}(`{3,}|~{3,})/;
+const RULE = /^ {0,3}([-*_])(?:\s*\1){2,}\s*$/;
+const ITEM = /^(\s*)([-*+]|\d{1,9}[.)])\s+(.*)$/;
+const TABLE_SEPARATOR = /^\s*\|?\s*:?-+:?\s*(?:\|\s*:?-+:?\s*)*\|?\s*$/;
+const QUOTE = /^ {0,3}>\s?(.*)$/;
+const ESCAPABLE = /[\\`*_[\]#|()~>+\-.!{}]/;
+
+function startsBlock(line: string, next: string | undefined): boolean {
+  return HEADING.test(line) || FENCE.test(line) || RULE.test(line) || ITEM.test(line) || QUOTE.test(line)
+    || (line.includes("|") && next !== undefined && TABLE_SEPARATOR.test(next) && next.includes("-"));
+}
+
+/** 인라인 서식을 run 목록으로 바꾼다. 닫는 표시가 없는 `*`·`**`는 글자로 남긴다. */
+export function parseInline(source: string): Run[] {
+  const runs: Run[] = [];
+  let bold = false;
+  let italic = false;
+  let buffer = "";
+  const flush = () => {
+    if (buffer) runs.push({ text: buffer, ...(bold ? { bold } : {}), ...(italic ? { italic } : {}) });
+    buffer = "";
+  };
+  const src = source.replace(/<br\s*\/?>/gi, "\n");
+  for (let i = 0; i < src.length;) {
+    const ch = src[i]!;
+    if (ch === "\\" && i + 1 < src.length && ESCAPABLE.test(src[i + 1]!)) { buffer += src[i + 1]; i += 2; continue; }
+    if (ch === "`") {
+      const ticks = /^`+/.exec(src.slice(i))![0];
+      const end = src.indexOf(ticks, i + ticks.length);
+      if (end > 0) {
+        flush();
+        runs.push({ text: src.slice(i + ticks.length, end).replace(/^ (.+) $/, "$1"), code: true, ...(bold ? { bold } : {}), ...(italic ? { italic } : {}) });
+        i = end + ticks.length;
+        continue;
+      }
+      buffer += ticks; i += ticks.length; continue;
+    }
+    if (ch === "[") {
+      const link = /^\[([^\]\n]+)\]\(([^)\s]+)(?:\s+"[^"]*")?\)/.exec(src.slice(i));
+      if (link) {
+        flush();
+        for (const run of parseInline(link[1]!)) runs.push({ ...run, ...(bold ? { bold } : {}), ...(italic ? { italic } : {}), href: link[2]! });
+        i += link[0].length;
+        continue;
+      }
+    }
+    if (src.startsWith("***", i) && ((bold && italic) || src.indexOf("***", i + 3) > 0)) { flush(); bold = !bold; italic = !italic; i += 3; continue; }
+    const pair = src.slice(i, i + 2);
+    if ((pair === "**" || pair === "__") && (bold || src.indexOf(pair, i + 2) > 0)) { flush(); bold = !bold; i += 2; continue; }
+    if (ch === "*" && (italic ? true : src[i + 1] !== " " && src.indexOf("*", i + 1) > 0)) { flush(); italic = !italic; i += 1; continue; }
+    buffer += ch;
+    i += 1;
+  }
+  flush();
+  return runs;
+}
+
+function splitRow(line: string): string[] {
+  let body = line.trim();
+  if (body.startsWith("|")) body = body.slice(1);
+  if (body.endsWith("|") && !body.endsWith("\\|")) body = body.slice(0, -1);
+  const cells: string[] = [];
+  let current = "";
+  let inCode = false;
+  for (let i = 0; i < body.length; i++) {
+    const ch = body[i]!;
+    if (ch === "\\" && body[i + 1] === "|") { current += "|"; i++; continue; }
+    if (ch === "`") inCode = !inCode;
+    if (ch === "|" && !inCode) { cells.push(current.trim()); current = ""; continue; }
+    current += ch;
+  }
+  cells.push(current.trim());
+  return cells;
+}
+
+export function parseMarkdown(source: string): Block[] {
+  const lines = source.replace(/\r\n?/g, "\n").split("\n");
+  const blocks: Block[] = [];
+  for (let i = 0; i < lines.length;) {
+    const line = lines[i]!;
+    if (!line.trim()) { i++; continue; }
+    const fence = FENCE.exec(line);
+    if (fence) {
+      const marker = fence[1]!;
+      const body: string[] = [];
+      for (i++; i < lines.length && !lines[i]!.trimStart().startsWith(marker); i++) body.push(lines[i]!);
+      i++; // 닫는 펜스(없으면 문서 끝)
+      blocks.push({ kind: "code", lines: body });
+      continue;
+    }
+    const heading = HEADING.exec(line);
+    if (heading) { blocks.push({ kind: "heading", level: heading[1]!.length, runs: parseInline(heading[2]!) }); i++; continue; }
+    if (RULE.test(line)) { blocks.push({ kind: "rule" }); i++; continue; }
+    if (line.includes("|") && i + 1 < lines.length && TABLE_SEPARATOR.test(lines[i + 1]!) && lines[i + 1]!.includes("-")) {
+      const header = splitRow(line);
+      const rows: Run[][][] = [];
+      for (i += 2; i < lines.length && lines[i]!.trim() && lines[i]!.includes("|"); i++) {
+        const cells = splitRow(lines[i]!);
+        rows.push(header.map((_, index) => parseInline(cells[index] ?? "")));
+      }
+      blocks.push({ kind: "table", header: header.map(parseInline), rows });
+      continue;
+    }
+    if (QUOTE.test(line)) {
+      const body: string[] = [];
+      for (; i < lines.length && QUOTE.test(lines[i]!); i++) body.push(QUOTE.exec(lines[i]!)![1]!);
+      blocks.push({ kind: "quote", runs: parseInline(body.join("\n").trim()) });
+      continue;
+    }
+    if (ITEM.test(line)) {
+      const items: ListItem[] = [];
+      const indents: number[] = [];
+      for (; i < lines.length;) {
+        const current = lines[i]!;
+        const item = ITEM.exec(current);
+        if (item) {
+          const indent = item[1]!.replace(/\t/g, "    ").length;
+          while (indents.length && indents[indents.length - 1]! > indent) indents.pop();
+          if (!indents.length || indents[indents.length - 1]! < indent) indents.push(indent);
+          items.push({ level: Math.min(indents.length - 1, 2), ordered: /\d/.test(item[2]!), runs: parseInline(item[3]!.replace(/^\[[ xX]\]\s+/, (box) => (/[xX]/.test(box) ? "☑ " : "☐ "))) });
+          i++;
+          continue;
+        }
+        // 들여 쓴 이어지는 줄은 직전 항목에 붙인다. 빈 줄 뒤에 항목이 오면 같은 목록이 이어진다.
+        if (current.trim() && /^\s+/.test(current) && items.length && !startsBlock(current.trim(), lines[i + 1])) {
+          const last = items[items.length - 1]!;
+          last.runs = [...last.runs, { text: " " }, ...parseInline(current.trim())];
+          i++;
+          continue;
+        }
+        if (!current.trim() && i + 1 < lines.length && ITEM.test(lines[i + 1]!)) { i++; continue; }
+        break;
+      }
+      blocks.push({ kind: "list", items });
+      continue;
+    }
+    const body: string[] = [line.trim()];
+    for (i++; i < lines.length && lines[i]!.trim() && !startsBlock(lines[i]!, lines[i + 1]); i++) body.push(lines[i]!.trim());
+    blocks.push({ kind: "paragraph", runs: parseInline(body.join(" ")) });
+  }
+  return blocks;
+}
+
+export function plainText(runs: readonly Run[]): string { return runs.map((run) => run.text).join(""); }
+
+/** 결과 보고용 개요: 제목 목록, 제목이 없으면 앞 문단 몇 개. */
+export function outline(blocks: readonly Block[], limit = 12): string[] {
+  const headings = blocks.filter((block): block is Extract<Block, { kind: "heading" }> => block.kind === "heading")
+    .map((block) => `${"#".repeat(block.level)} ${plainText(block.runs)}`);
+  if (headings.length) return headings.length > limit ? [...headings.slice(0, limit), `… 제목 ${headings.length - limit}개 더`] : headings;
+  return blocks.filter((block): block is Extract<Block, { kind: "paragraph" }> => block.kind === "paragraph")
+    .slice(0, 3).map((block) => plainText(block.runs).slice(0, 120));
+}
+
+function escapeHtml(text: string): string {
+  return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+
+function htmlRuns(runs: readonly Run[]): string {
+  return runs.map((run) => {
+    let html = escapeHtml(run.text).replace(/\n/g, "<br>");
+    if (run.code) html = `<code>${html}</code>`;
+    if (run.italic) html = `<em>${html}</em>`;
+    if (run.bold) html = `<strong>${html}</strong>`;
+    if (run.href) html = `<a href="${escapeHtml(run.href)}">${html}</a>`;
+    return html;
+  }).join("");
+}
+
+function htmlList(items: readonly ListItem[]): string {
+  let html = "";
+  const open: string[] = [];
+  let depth = -1;
+  for (const item of items) {
+    const tag = item.ordered ? "ol" : "ul";
+    while (depth > item.level) { html += `</li></${open.pop()}>`; depth--; }
+    if (depth === item.level && open[open.length - 1] !== tag) { html += `</li></${open.pop()}>`; depth--; }
+    if (depth === item.level) html += "</li>";
+    while (depth < item.level) { html += `<${tag}>`; open.push(tag); depth++; if (depth < item.level) html += "<li>"; }
+    html += `<li>${htmlRuns(item.runs)}`;
+  }
+  while (open.length) html += `</li></${open.pop()}>`;
+  return html;
+}
+
+const CSS = `@page { size: A4; margin: 18mm 16mm; }
+body { font-family: "Malgun Gothic", "맑은 고딕", "Apple SD Gothic Neo", "Noto Sans KR", sans-serif; font-size: 10.5pt; line-height: 1.6; color: #111; }
+h1 { font-size: 20pt; border-bottom: 1px solid #999; padding-bottom: 4px; } h2 { font-size: 15pt; } h3 { font-size: 12.5pt; } h4, h5, h6 { font-size: 11pt; }
+h1, h2, h3, h4, h5, h6 { margin: 1.1em 0 0.4em; page-break-after: avoid; }
+table { border-collapse: collapse; width: 100%; margin: 0.6em 0; page-break-inside: auto; } tr { page-break-inside: avoid; }
+th, td { border: 1px solid #888; padding: 4px 6px; text-align: left; vertical-align: top; } th { background: #eee; }
+pre { background: #f4f4f4; padding: 8px; white-space: pre-wrap; word-break: break-all; font-size: 9pt; }
+code { font-family: Consolas, "D2Coding", monospace; } blockquote { margin: 0.6em 0; padding-left: 10px; border-left: 3px solid #bbb; color: #444; }
+hr { border: 0; border-top: 1px solid #aaa; }`;
+
+export function toHtml(blocks: readonly Block[], title: string): string {
+  const body = blocks.map((block) => {
+    switch (block.kind) {
+      case "heading": return `<h${block.level}>${htmlRuns(block.runs)}</h${block.level}>`;
+      case "paragraph": return `<p>${htmlRuns(block.runs)}</p>`;
+      case "list": return htmlList(block.items);
+      case "table": return `<table><thead><tr>${block.header.map((cell) => `<th>${htmlRuns(cell)}</th>`).join("")}</tr></thead><tbody>${
+        block.rows.map((row) => `<tr>${row.map((cell) => `<td>${htmlRuns(cell)}</td>`).join("")}</tr>`).join("")}</tbody></table>`;
+      case "code": return `<pre><code>${escapeHtml(block.lines.join("\n"))}</code></pre>`;
+      case "quote": return `<blockquote>${htmlRuns(block.runs)}</blockquote>`;
+      case "rule": return "<hr>";
+    }
+  }).join("\n");
+  return `<!doctype html>\n<html lang="ko"><head><meta charset="utf-8"><title>${escapeHtml(title)}</title><style>${CSS}</style></head><body>\n${body}\n</body></html>\n`;
+}