elanous 0.2.9 → 0.2.11

package/plugins/card-followup/graphs/run-step.ts

@@ -37,10 +37,50 @@ function firstObject(raw: string): Data {
 async function cli(bin: string, args: string[]): Promise<string> {
   const child = Bun.spawn([bin, ...args], { stdout: 'pipe', stderr: 'pipe', env: process.env });
   const [stdout, stderr, status] = await Promise.all([new Response(child.stdout).text(), new Response(child.stderr).text(), child.exited]);
-  if (status !== 0) throw new Error(`${args[0]} 실패: ${(stderr || stdout).slice(0, 200)}`);
+  if (status !== 0) throw new Error(`${args[0]} 실패: ${(stderr || stdout).slice(0, 200)}`, { cause: `${stderr}\n${stdout}` });
   return stdout;
 }
 
+const sleep = (ms: number) => new Promise<void>(resolve => setTimeout(resolve, ms));
+
+function transientAskReason(error: unknown): string | null {
+  const message = error instanceof Error ? `${error.message}\n${String(error.cause ?? '')}` : String(error);
+  if (/socket connection was closed/i.test(message)) return 'socket';
+  if (/\bECONNRESET\b/i.test(message)) return 'ECONNRESET';
+  if (/\bETIMEDOUT\b/i.test(message)) return 'ETIMEDOUT';
+  if (/\bEPIPE\b/i.test(message)) return 'EPIPE';
+  if (/fetch failed/i.test(message)) return 'fetch';
+  const http = /\b(?:HTTP(?:\/[\d.]+)?\s*[:=]?\s*|status(?:\s+code)?\s*[:=]?\s*)(502|503|504|429)\b|\b(502|503|504|429)\s+(?:Bad Gateway|Service Unavailable|Gateway Timeout|Too Many Requests)\b/i.exec(message);
+  return http ? `HTTP${http[1] ?? http[2]}` : null;
+}
+
+export async function askWithRetry(payload: Data, run = cli, wait = sleep): Promise<Data> {
+  const args = ['ask', '--json', JSON.stringify(payload)];
+  let raw: string;
+  let retried = false;
+  try {
+    raw = await run(elanous, args);
+  } catch (error) {
+    const reason = transientAskReason(error);
+    if (!reason) throw error;
+    console.error(`card-followup: ask retry (${reason})`);
+    await wait(3000);
+    retried = true;
+    try {
+      raw = await run(elanous, args);
+    } catch (retryError) {
+      throw new Error(`${retryError instanceof Error ? retryError.message : String(retryError)} · 한 번 다시 했지만 실패`);
+    }
+  }
+  try {
+    const response = JSON.parse(raw) as Data;
+    return firstObject(typeof response.reply === 'string' ? response.reply : JSON.stringify(response));
+  } catch (error) {
+    if (retried) throw new Error(`${error instanceof Error ? error.message : String(error)} · 한 번 다시 했지만 실패`);
+    throw error;
+  }
+}
+
 function absolute(path: string, label: string): string {
   const expanded = path.startsWith('~/') ? join(homedir(), path.slice(2)) : path;
   if (!isAbsolute(expanded)) throw new Error(`${label}: 절대 경로 필요`);
@@ -82,13 +122,15 @@ function sources(raw: string): { title: string; url: string; snippet: string }[]
   });
 }
 
+const elanous = process.env.CARD_FOLLOWUP_ELANOUS_BIN || 'elanous';
+
+if (import.meta.main) {
 const contextFile = process.env.ELANOUS_GRAPH_CONTEXT;
 if (!contextFile) throw new Error('ELANOUS_GRAPH_CONTEXT 필요');
 const context = object(JSON.parse(readFileSync(contextFile, 'utf8')));
 const input = object(context.input);
 const outputs = object(context.outputs);
 const step = process.argv[2];
-const elanous = process.env.CARD_FOLLOWUP_ELANOUS_BIN || 'elanous';
 const codex = process.env.CARD_FOLLOWUP_CODEX_BIN || 'codex';
 const result = (data: Data) => console.log(JSON.stringify(data.outcome ? data : { outcome: 'ok', ...data }));
 
@@ -155,11 +197,7 @@ try {
     const read = object(outputs['read-card']);
     const card = object(read.card ?? read);
     const research = object(outputs.research);
-    const ask = async (payload: Data): Promise<Data> => {
-      const response = JSON.parse(await cli(elanous, ['ask', '--json', JSON.stringify(payload)])) as Data;
-      return firstObject(typeof response.reply === 'string' ? response.reply : JSON.stringify(response));
-    };
-    const strategy = await buildStrategy({ card, research, context: text(input.context), offer: text(input.offer), ask });
+    const strategy = await buildStrategy({ card, research, context: text(input.context), offer: text(input.offer), ask: askWithRetry });
     const fallback = dirname(contextFile).endsWith('.json.contexts') ? dirname(contextFile).slice(0, -'.json.contexts'.length) : dirname(contextFile);
     const outDir = input.outDir === undefined ? fallback : absolute(text(input.outDir), 'outDir');
     const crm = input.crm === undefined ? join(outDir, 'crm.csv') : absolute(text(input.crm), 'crm');
@@ -182,10 +220,6 @@ try {
     const marker = /\s*\[S(\d+)\]/g;
     const strip = (value: string) => value.replace(marker, '').trim();
     const sentencesOf = (value: string) => value.split(/(?<=[.!?。！？])\s+|\n+/).map(s => s.trim()).filter(Boolean);
-    const ask = async (payload: Data): Promise<Data> => {
-      const response = JSON.parse(await cli(elanous, ['ask', '--json', JSON.stringify(payload)])) as Data;
-      return firstObject(typeof response.reply === 'string' ? response.reply : JSON.stringify(response));
-    };
     // A Korean meeting note on an English card used to be pasted verbatim into the English mail
     // («Hi Joosung, 마케터의 밤에서 인사.» · 10-01 dry run). Across languages the note is translated, not copied.
     const crossLanguage = language === 'en' && /[가-힣]/.test(contextLine);
@@ -200,7 +234,7 @@ try {
     let accepted: { warnings: string[]; draft: Data; facts: { text: string; url: string }[] } | undefined;
     let lastProblem = '';
     for (let attempt = 0; attempt < 3 && !accepted; attempt++) {
-      const draft = await ask({ task: 'draft', instruction: instruction + feedback, card, context: contextLine, sender: text(input.sender), language, evidence: numbered, approach: { problem: text(approach.problem), proposal: text(approach.proposal), channel: text(approach.channel) } });
+      const draft = await askWithRetry({ task: 'draft', instruction: instruction + feedback, card, context: contextLine, sender: text(input.sender), language, evidence: numbered, approach: { problem: text(approach.problem), proposal: text(approach.proposal), channel: text(approach.channel) } });
       const parts = { subject: text(draft.subject), body: text(draft.body), linkedin: text(draft.linkedin), question: text(draft.question) };
       if (!parts.subject || !parts.body || !parts.linkedin || !parts.question) { lastProblem = '초안 필수 필드 없음'; feedback = ' 이전 응답에 필드가 빠졌다.'; continue; }
       const body = strip(parts.body), linkedin = strip(parts.linkedin);
@@ -218,7 +252,7 @@ try {
       if (badCite) shape.push(`없는 출처 번호: ${badCite.raw}`);
       if (shape.length) { lastProblem = shape.join(' · '); feedback = ` 이전 초안 문제: ${lastProblem}. 모두 고쳐 다시 작성하라.`; continue; }
       // Every sentence is judged against the card, the context and only the evidence it cites — a company name alone is identity, not a claim.
-      const verdict = await ask({
+      const verdict = await askWithRetry({
         task: 'verify',
         instruction: '각 문장에 대해, 받는 사람·그 회사·시장에 관한 사실 주장이 명함 필드, context, 또는 그 문장이 인용한 evidence 로 뒷받침되는지 판정하라. 인사·호칭·명함에 있는 이름/회사/직함 언급·제안·질문·보내는 사람의 의도는 사실 주장이 아니다. JSON 객체만 출력: {"unsupported":[뒷받침 안 되는 문장 번호]}',
         card, context: contextLine,
@@ -274,3 +308,4 @@ try {
 } catch (error) {
   result({ outcome: 'fail', reason: error instanceof Error ? error.message : String(error) });
 }
+}

package/plugins/doc-draft/graphs/doc-draft.yaml

@@ -3,12 +3,12 @@ version: 1
 entry_node: draft
 terminal_nodes: [done, failed]
 nodes:
-  - { node_id: draft, kind: agent, recipe: 'cmd:draft', max_visits: 1 }
-  - { node_id: check, kind: agent, recipe: 'cmd:check', max_visits: 1 }
+  - { node_id: draft, kind: agent, recipe: 'cmd:draft', max_visits: 2 }
+  - { node_id: check, kind: agent, recipe: 'cmd:check', max_visits: 2 }
   - { node_id: report, kind: agent, recipe: 'cmd:report', max_visits: 1 }
   - { node_id: done, kind: gate, max_visits: 1 }
   - { node_id: failed, kind: gate, max_visits: 1 }
 edges:
   - { from: draft, on: outcome, map: { ok: check, fail: failed } }
-  - { from: check, on: outcome, map: { ok: report, fail: failed } }
+  - { from: check, on: outcome, map: { ok: report, revise: draft, fail: failed } }
   - { from: report, on: outcome, map: { ok: done, fail: failed } }

package/plugins/doc-draft/graphs/run-step.ts

@@ -80,17 +80,24 @@ try {
   if (!topic) throw new Error('topic is required');
   const step = process.argv[2] ?? '';
   if (step === 'draft') {
-    const prompt = `Write ONE ${kind} document in ${text(input.language) || 'ko'} for ${text(input.audience) || 'the intended reader'}. Request: ${topic}. Context (source material, not a claim to invent): ${text(input.context) || '(none)'}. Return Markdown only: one # title line and a substantive body of 15–${limits[typedKind]} whitespace-separated words. Cover every item in the request. ${kind === 'exec-onepager' ? 'Include exactly these four ## sections with substantive content: 요약, 핵심 숫자, 결정 요청, 다음 단계. For unknown numeric figures write “자료 미제공 — 확인 필요” under 핵심 숫자, rather than inventing numbers.' : ''} No empty placeholders or fabricated facts. This is a DRAFT only: never claim it was published, sent, paid for, or approved; do not perform those actions.`;
+    const previousReason = text(object(outputs.check).reason);
+    const previousDraft = text(object(outputs.draft).markdown);
+    const prompt = `Write ONE ${kind} document in ${text(input.language) || 'ko'} for ${text(input.audience) || 'the intended reader'}. Request: ${topic}. Context (source material, not a claim to invent): ${text(input.context) || '(none)'}. Return Markdown only: one # title line and a substantive body of 15–${limits[typedKind]} whitespace-separated words. Cover every item in the request. ${kind === 'exec-onepager' ? 'Include exactly these four ## sections with substantive content: 요약, 핵심 숫자, 결정 요청, 다음 단계. For unknown numeric figures write “자료 미제공 — 확인 필요” under 핵심 숫자, rather than inventing numbers.' : ''} No empty placeholders or fabricated facts. This is a DRAFT only: never claim it was published, sent, paid for, or approved; do not perform those actions.${previousReason ? ` The previous draft failed check for this reason — fix it and rewrite: ${previousReason}. Previous draft: ${previousDraft}` : ''}`;
     const markdown = await ask(prompt);
     console.log(JSON.stringify({ outcome: 'ok', markdown }));
   } else if (step === 'check') {
     const markdown = text(object(outputs.draft).markdown);
     const error = validate(markdown, typedKind);
-    if (error) throw new Error(error);
-    const response = await ask(`Review this draft against the original request. Check length, empty fields, missing requested items, and invented claims (including claims it was published, sent, paid for, or approved). Request: ${topic}. Context: ${text(input.context) || '(none)'}. Draft: ${markdown}. Return ONLY JSON {"ok":true|false,"reason":"..."}. Set ok=false for any missing request item or unverifiable factual claim. A clearly labelled missing number is allowed; do not invent facts.`);
-    const verdict = object(JSON.parse(response.replace(/^```(?:json)?\s*|\s*```$/gi, '').trim()) as unknown);
-    if (verdict.ok !== true) throw new Error(text(verdict.reason) || 'draft review failed');
-    console.log(JSON.stringify({ outcome: 'ok', markdown, words: wordCount(markdown) }));
+    let reason = error;
+    if (!reason) {
+      const response = await ask(`Review this draft against the original request. Check length, empty fields, missing requested items, and invented claims (including claims it was published, sent, paid for, or approved). Request: ${topic}. Context: ${text(input.context) || '(none)'}. Draft: ${markdown}. Return ONLY JSON {"ok":true|false,"reason":"..."}. Set ok=false for any missing request item or unverifiable factual claim. A clearly labelled missing number is allowed; do not invent facts.`);
+      const verdict = object(JSON.parse(response.replace(/^```(?:json)?\s*|\s*```$/gi, '').trim()) as unknown);
+      if (verdict.ok !== true) reason = text(verdict.reason) || 'draft review failed';
+    }
+    if (reason) {
+      const outcome = object(outputs.check).outcome === 'revise' ? 'fail' : 'revise';
+      console.log(JSON.stringify({ outcome, reason, ...(outcome === 'fail' ? { error: reason } : {}) }));
+    } else console.log(JSON.stringify({ outcome: 'ok', markdown, words: wordCount(markdown) }));
   } else if (step === 'report') {
     const checked = object(outputs.check);
     if (checked.outcome !== 'ok') throw new Error('missing checked draft');

package/plugins/elanous-hwp/README.md

@@ -0,0 +1,25 @@
+# elanous-hwp
+
+**S** — HWPX files carry Korean office documents in ZIP/XML form. **C** — Markdown-only tooling cannot read their paragraphs, headings or tables. **Q** — How can these documents be exchanged without external binaries? **A** — This official plugin provides a built-in ZIP/XML reader and a minimal writer.
+
+```sh
+bun plugins/elanous-hwp/cli.ts to-md input.hwpx output.md
+bun plugins/elanous-hwp/cli.ts from-md input.md output.hwpx
+```
+
+The plugin also registers `HwpxToMarkdown` (HWPX path → Markdown text) and `MarkdownToHwpx` (Markdown path and new HWPX output path) as host LLM tools. `to-md` reads spine-ordered HWPX sections and emits paragraphs, headings (referenced paragraph properties with OUTLINE heading levels 0–5), and GFM tables. `from-md` writes paragraphs and headings into a minimal HWPX ZIP; it does not write tables. Existing output files are not overwritten. `.hwp` legacy binary files are **not supported**: save them as `.hwpx` first. No external executable, Python package, or third-party ZIP/XML library is required. This first piece does not validate page layout or promise round-trip preservation of unsupported styling, images, or merged cells.
+
+## Verification record
+
+- Official manifest and both host conversion tools: `plugin.json` (`trust: official`, `main: ./plugin.ts`), `plugin.ts`, and `converter.test.ts` (host tool test and manifest loader assertions).
+- Fixed compressed sample → OUTLINE level 0 heading with reference ID 4, ordinary paragraph with nonzero reference ID 2, joined paragraph, GFM table and escaped pipe, then mixed text/table/text within one run in original order: `fixtures/fixed.hwpx` and `converter.test.ts` (fixed sample test). `fixtures/fixed-controls.hwpx` checks text/lineBreak/tab interleaving inside one `<hp:t>`. `fixtures/fixed-table-controls.hwpx` checks that a cell's lineBreak and separate paragraphs become `<br>` within one GFM row (test at `converter.test.ts:64-70`; implementation at `converter.ts:153-162`).
+- Minimal Markdown → HWPX → identical Markdown; unsupported Markdown tables fail explicitly: `converter.ts` and `converter.test.ts` (round-trip test). ATX headings end on their own line even without a blank separator: `converter.ts:198-220` and `converter.test.ts:55-62` assert three distinct generated XML content paragraphs (four including the section-properties paragraph), properties 1/0/2. Multiline ordinary paragraphs retain lineBreak controls (`converter.test.ts:47-53`). Legacy HWP guidance and no-overwrite behavior: `cli.ts`, `plugin.ts`, and `converter.test.ts` (CLI test).
+- Zero external runtime binary dependencies: `converter.ts` uses `node:zlib`; `cli.ts` and `plugin.ts` use `node:fs`. The independent consumer below is a *verification-only* script from the existing pack, not invoked by the plugin.
+- `bun test plugins/elanous-hwp/converter.test.ts 2>&1 | tail -6`: `8 pass`, `0 fail`, `Ran 8 tests across 1 file. [58.00ms]` (40 assertions). This includes a spawned `bun plugins/elanous-hwp/cli.ts to-md …` subprocess in the CLI test.
+- `bun bin/elanous.mjs --test self typecheck 2>&1 | tail -4`: `✅ 변경 파일 타입 검사 통과 (4개 파일 검사…)`.
+- `bun bin/elanous.mjs --test self gate --changed 2>&1 | tail -20`: `tests: pass (1 files)` and `[test-count] changed-test-files=1, test-cases=0→8, decrease=0`; the gate explicitly lists six files outside the bun test runner, including fixture archives (these archives are read by the focused tests).
+- Earlier `bun .elanous-test/scratch/verify-generated-hwpx.ts`: `independent HWPX consumer: PASS — title, paragraph, OPF spine` (previous run, not a fresh verification; uses the repository's existing `packs/elanous-hwp/test/consumer.py` only for verification).
+- Mutation (this review, table): changed `converter.ts:157` replacement of internal newlines from `<br>` to empty; `bun test plugins/elanous-hwp/converter.test.ts -t 'fixed HWPX table sample retains cell line breaks and multiple cell paragraphs within GFM rows' 2>&1 | tail -12` returned `0 pass`, `1 fail`, `Ran 1 test across 1 file. [29.00ms]`. Failing check verbatim: `(fail) fixed HWPX table sample retains cell line breaks and multiple cell paragraphs within GFM rows [2.78ms]`. Restored `<br>`.
+- Mutation (this review, ATX): changed `converter.ts:209` heading regex from `{1,6}` to `{7,8}`; `bun test plugins/elanous-hwp/converter.test.ts -t 'adjacent ATX headings terminate at the end of their line even without blank separators' 2>&1 | tail -10` returned `0 pass`, `1 fail`, `Ran 1 test across 1 file. [37.00ms]`. Failing check verbatim: `(fail) adjacent ATX headings terminate at the end of their line even without blank separators [2.73ms]`. Restored `{1,6}`; full focused file passed `8 pass`, `0 fail` afterward.
+- Preservation: `git status --short -- packs/elanous-hwp` returns no lines; the separate existing pack is unchanged. English release note: `release/next.md:30`. Review disposition: both must-fixes apply and are compatible with the requested Markdown and HWPX conversion; no refutation.
+- Commit status: intentionally uncommitted. This self-implement child is explicitly prohibited from git commit/push/PR/branch changes; the parent harness owns the approval-gated commit.

package/plugins/elanous-hwp/cli.ts

@@ -0,0 +1,22 @@
+import { readFileSync, writeFileSync } from 'node:fs';
+import { hwpxToMarkdown, markdownToHwpx } from './converter.js';
+
+export function main(args: string[]): void {
+  const [command, input, output] = args;
+  if (!input || !output || !['to-md', 'from-md'].includes(command ?? '')) {
+    throw new Error('Usage: bun plugins/elanous-hwp/cli.ts to-md input.hwpx output.md | from-md input.md output.hwpx');
+  }
+  if (/\.hwp$/i.test(input) || /\.hwp$/i.test(output)) throw new Error('HWP(옛 바이너리)는 지원 안 함 · hwpx 로 저장해 달라');
+  if (command === 'to-md') {
+    if (!/\.hwpx$/i.test(input) || !/\.md$/i.test(output)) throw new Error('Expected .hwpx input and .md output');
+    writeFileSync(output, hwpxToMarkdown(readFileSync(input), input), { flag: 'wx' });
+  } else {
+    if (!/\.md$/i.test(input) || !/\.hwpx$/i.test(output)) throw new Error('Expected .md input and .hwpx output');
+    writeFileSync(output, markdownToHwpx(readFileSync(input, 'utf8')), { flag: 'wx' });
+  }
+}
+
+if (import.meta.main) {
+  try { main(process.argv.slice(2)); }
+  catch (error) { console.error(error instanceof Error ? error.message : error); process.exitCode = 1; }
+}

package/plugins/elanous-hwp/converter.ts

@@ -0,0 +1,237 @@
+import { deflateRawSync, inflateRawSync } from 'node:zlib';
+
+const encoder = new TextEncoder();
+const decoder = new TextDecoder('utf-8', { fatal: true });
+const HP = 'http://www.hancom.co.kr/hwpml/2011/paragraph';
+const HH = 'http://www.hancom.co.kr/hwpml/2011/head';
+/** HWPX section root lives in the section namespace (OWPML `hs:sec`), not the paragraph one. */
+const HS = 'http://www.hancom.co.kr/hwpml/2011/section';
+const OPF = 'http://www.idpf.org/2007/opf/';
+const HWP_NOTICE = 'HWP(옛 바이너리)는 지원 안 함 · hwpx 로 저장해 달라';
+
+type XmlNode = { name: string; attrs: Record<string, string>; children: XmlNode[]; content: (XmlNode | string)[] };
+const local = (name: string) => name.split(':').pop()!;
+const xmlEscape = (value: string) => value.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;');
+function unescapeXml(value: string): string {
+  return value.replace(/&(#x[\da-f]+|#\d+|amp|lt|gt|quot|apos);/gi, (_, entity: string) => {
+    const named: Record<string, string> = { amp: '&', lt: '<', gt: '>', quot: '"', apos: "'" };
+    if (entity[0] !== '#') return named[entity] ?? `&${entity};`;
+    const cp = entity[1]?.toLowerCase() === 'x' ? parseInt(entity.slice(2), 16) : parseInt(entity.slice(1), 10);
+    if (cp > 0x10ffff || cp === 0 || (cp >= 0xd800 && cp <= 0xdfff)) throw new Error('Invalid XML character');
+    return String.fromCodePoint(cp);
+  });
+}
+function parseXml(xml: string): XmlNode {
+  if (/<!DOCTYPE|<!ENTITY/i.test(xml)) throw new Error('External XML entities are not supported');
+  const root: XmlNode = { name: '', attrs: {}, children: [], content: [] };
+  const stack = [root];
+  const tokens = xml.match(/<[^>]*>|[^<]+/g) ?? [];
+  for (const token of tokens) {
+    if (token.startsWith('<?') || token.startsWith('<!--')) continue;
+    if (token.startsWith('</')) {
+      if (local(stack.at(-1)!.name) !== local(token.slice(2, -1).trim()) || stack.length === 1) throw new Error('Invalid HWPX XML');
+      stack.pop();
+    } else if (token.startsWith('<')) {
+      if (token.startsWith('<!')) throw new Error('Unsupported HWPX XML declaration');
+      const match = /^<([\w:.-]+)(?:\s|\/?>)/.exec(token);
+      if (!match) throw new Error('Invalid HWPX XML');
+      const attrs: Record<string, string> = {};
+      for (const attr of token.slice(match[0].length).matchAll(/([\w:.-]+)\s*=\s*(["'])(.*?)\2/g)) attrs[local(attr[1]!)] = unescapeXml(attr[3]!);
+      const node: XmlNode = { name: local(match[1]!), attrs, children: [], content: [] };
+      stack.at(-1)!.children.push(node);
+      stack.at(-1)!.content.push(node);
+      if (!token.endsWith('/>')) stack.push(node);
+    } else {
+      stack.at(-1)!.content.push(unescapeXml(token));
+    }
+  }
+  if (stack.length !== 1 || root.children.length !== 1) throw new Error('Invalid HWPX XML');
+  return root.children[0]!;
+}
+const children = (node: XmlNode, name: string) => node.children.filter(child => child.name === name);
+const descendants = (node: XmlNode, name: string): XmlNode[] => node.children.flatMap(child => [ ...(child.name === name ? [child] : []), ...descendants(child, name) ]);
+const nodeText = (node: XmlNode): string => node.name === 'lineBreak' ? '\n' : node.name === 'tab' ? '\t' : node.content.map(part => typeof part === 'string' ? (node.name === 't' ? part : '') : nodeText(part)).join('');
+
+function crc32(bytes: Uint8Array): number {
+  let crc = -1;
+  for (const byte of bytes) {
+    crc ^= byte;
+    for (let i = 0; i < 8; i++) crc = (crc >>> 1) ^ (crc & 1 ? 0xedb88320 : 0);
+  }
+  return (crc ^ -1) >>> 0;
+}
+function readZip(bytes: Uint8Array): Map<string, Uint8Array> {
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  let eocd = -1;
+  for (let i = bytes.length - 22; i >= Math.max(0, bytes.length - 65557); i--) {
+    if (view.getUint32(i, true) === 0x06054b50 && i + 22 + view.getUint16(i + 20, true) === bytes.length) { eocd = i; break; }
+  }
+  if (eocd < 0 || view.getUint16(eocd + 4, true) !== 0 || view.getUint16(eocd + 6, true) !== 0) throw new Error('Invalid HWPX ZIP');
+  if (view.getUint16(eocd + 8, true) !== view.getUint16(eocd + 10, true) || view.getUint32(eocd + 16, true) + view.getUint32(eocd + 12, true) > eocd) throw new Error('Invalid HWPX ZIP directory');
+  const count = view.getUint16(eocd + 10, true);
+  if (count > 1024) throw new Error('HWPX ZIP has too many entries');
+  let cursor = view.getUint32(eocd + 16, true);
+  const entries = new Map<string, Uint8Array>();
+  const directoryEnd = view.getUint32(eocd + 16, true) + view.getUint32(eocd + 12, true);
+  for (let i = 0; i < count; i++) {
+    if (cursor + 46 > directoryEnd || view.getUint32(cursor, true) !== 0x02014b50) throw new Error('Invalid HWPX ZIP directory');
+    const flags = view.getUint16(cursor + 8, true), method = view.getUint16(cursor + 10, true);
+    const crc = view.getUint32(cursor + 16, true), packed = view.getUint32(cursor + 20, true), size = view.getUint32(cursor + 24, true);
+    const nameLen = view.getUint16(cursor + 28, true), extraLen = view.getUint16(cursor + 30, true), commentLen = view.getUint16(cursor + 32, true);
+    if (flags & 1 || size > 32 * 1024 * 1024 || packed > 32 * 1024 * 1024 || cursor + 46 + nameLen + extraLen + commentLen > bytes.length) throw new Error('Unsupported HWPX ZIP entry');
+    const name = decoder.decode(bytes.subarray(cursor + 46, cursor + 46 + nameLen));
+    const offset = view.getUint32(cursor + 42, true);
+    if (offset + 30 > bytes.length || view.getUint32(offset, true) !== 0x04034b50) throw new Error('Invalid HWPX ZIP entry');
+    const start = offset + 30 + view.getUint16(offset + 26, true) + view.getUint16(offset + 28, true);
+    if (start + packed > bytes.length) throw new Error('Truncated HWPX ZIP entry');
+    const content = method === 0 ? bytes.slice(start, start + packed) : method === 8 ? inflateRawSync(bytes.subarray(start, start + packed), { maxOutputLength: 32 * 1024 * 1024 }) : null;
+    if (!content || content.length !== size || crc32(content) !== crc || entries.has(name)) throw new Error('Invalid HWPX ZIP entry: ' + name);
+    entries.set(name, content);
+    cursor += 46 + nameLen + extraLen + commentLen;
+  }
+  if (cursor !== directoryEnd) throw new Error('Invalid HWPX ZIP directory');
+  return entries;
+}
+function writeZip(files: [string, string][]): Uint8Array {
+  const parts: Uint8Array[] = [], directory: Uint8Array[] = [];
+  let offset = 0;
+  const uint16 = (view: DataView, at: number, n: number) => view.setUint16(at, n, true);
+  const uint32 = (view: DataView, at: number, n: number) => view.setUint32(at, n >>> 0, true);
+  for (const [name, value] of files) {
+    const filename = encoder.encode(name), body = encoder.encode(value);
+    const method = name === 'mimetype' ? 0 : 8;
+    const packed = method === 0 ? body : deflateRawSync(body);
+    const crc = crc32(body);
+    const header = new Uint8Array(30 + filename.length), h = new DataView(header.buffer);
+    uint32(h, 0, 0x04034b50); uint16(h, 4, 20); uint16(h, 6, 0x800); uint16(h, 8, method);
+    uint32(h, 14, crc); uint32(h, 18, packed.length); uint32(h, 22, body.length); uint16(h, 26, filename.length);
+    header.set(filename, 30);
+    parts.push(header, packed);
+    const central = new Uint8Array(46 + filename.length), c = new DataView(central.buffer);
+    uint32(c, 0, 0x02014b50); uint16(c, 4, 20); uint16(c, 6, 20); uint16(c, 8, 0x800); uint16(c, 10, method);
+    uint32(c, 16, crc); uint32(c, 20, packed.length); uint32(c, 24, body.length); uint16(c, 28, filename.length); uint32(c, 42, offset);
+    central.set(filename, 46); directory.push(central);
+    offset += header.length + packed.length;
+  }
+  const dirSize = directory.reduce((sum, part) => sum + part.length, 0);
+  const end = new Uint8Array(22), e = new DataView(end.buffer);
+  uint32(e, 0, 0x06054b50); uint16(e, 8, files.length); uint16(e, 10, files.length); uint32(e, 12, dirSize); uint32(e, 16, offset);
+  const result = new Uint8Array(offset + dirSize + end.length);
+  let pos = 0;
+  for (const part of [...parts, ...directory, end]) { result.set(part, pos); pos += part.length; }
+  return result;
+}
+function sections(zip: Map<string, Uint8Array>): { paths: string[]; paraProps: Map<string, XmlNode> } {
+  const container = zip.get('META-INF/container.xml');
+  if (!container) throw new Error('HWPX container.xml is missing');
+  const path = descendants(parseXml(decoder.decode(container)), 'rootfile')[0]?.attrs['full-path'];
+  const opf = path && zip.get(path);
+  if (!opf || !path) throw new Error('HWPX package is missing');
+  const pkg = parseXml(decoder.decode(opf));
+  const manifest = new Map(descendants(pkg, 'item').map(item => [item.attrs.id, item.attrs.href]));
+  const base = path.slice(0, path.lastIndexOf('/') + 1);
+  const ordered = descendants(pkg, 'itemref').map(ref => {
+    const href = manifest.get(ref.attrs.idref);
+    if (!href) return undefined;
+    const relative = [...base.split('/'), ...href.split('/')].reduce<string[]>((parts, part) => {
+      if (part === '..') parts.pop(); else if (part && part !== '.') parts.push(part);
+      return parts;
+    }, []).join('/');
+    return relative.endsWith('.xml') && zip.has(relative) && parseXml(decoder.decode(zip.get(relative)!)).name === 'sec' ? relative : undefined;
+  }).filter((name): name is string => !!name);
+  if (!ordered.length) throw new Error('HWPX section is missing');
+  const headerHref = [...manifest.values()].find(href => href?.endsWith('header.xml'));
+  const headerPath = headerHref && [...base.split('/'), ...headerHref.split('/')].reduce<string[]>((parts, part) => {
+    if (part === '..') parts.pop(); else if (part && part !== '.') parts.push(part);
+    return parts;
+  }, []).join('/');
+  const header = headerPath && zip.get(headerPath);
+  const paraProps = new Map<string, XmlNode>();
+  if (header) for (const prop of descendants(parseXml(decoder.decode(header)), 'paraPr')) {
+    if (prop.attrs.id !== undefined) paraProps.set(prop.attrs.id, prop);
+  }
+  return { paths: ordered, paraProps };
+}
+function tableMarkdown(table: XmlNode): string {
+  const cellText = (tc: XmlNode): string => {
+    const paragraphs = descendants(tc, 'p');
+    const text = paragraphs.length ? paragraphs.map(nodeText).join('\n') : nodeText(tc);
+    return text.replace(/\\/g, '\\\\').replace(/\|/g, '\\|').replace(/\r\n|\r|\n/g, '<br>');
+  };
+  const rows = children(table, 'tr').map(tr => children(tr, 'tc').map(cellText));
+  if (!rows.length) return '';
+  return [rows[0], rows[0]!.map(() => '---'), ...rows.slice(1)].map(row => '| ' + row.join(' | ') + ' |').join('\n');
+}
+function paragraphMarkdown(p: XmlNode, paraProps: Map<string, XmlNode>): string[] {
+  const blocks: string[] = [];
+  let text = '';
+  const prop = paraProps.get(p.attrs.paraPrIDRef ?? '');
+  const heading = prop && children(prop, 'heading')[0];
+  const level = heading?.attrs.type === 'OUTLINE' ? Number(heading.attrs.level) : NaN;
+  const prefix = Number.isInteger(level) && level >= 0 && level <= 5 ? '#'.repeat(level + 1) + ' ' : '';
+  const flush = () => {
+    if (text.trim()) blocks.push(prefix + text.trim());
+    text = '';
+  };
+  const visit = (node: XmlNode): void => {
+    if (node.name === 'tbl') {
+      flush();
+      const md = tableMarkdown(node);
+      if (md) blocks.push(md);
+    } else if (node.name === 't' || node.name === 'lineBreak' || node.name === 'tab') {
+      text += nodeText(node);
+    } else {
+      for (const part of node.content) if (typeof part !== 'string') visit(part);
+    }
+  };
+  for (const run of children(p, 'run')) visit(run);
+  flush();
+  return blocks;
+}
+export function hwpxToMarkdown(bytes: Uint8Array, filename = 'document.hwpx'): string {
+  const oleSignature = [0xd0, 0xcf, 0x11, 0xe0, 0xa1, 0xb1, 0x1a, 0xe1];
+  if (/\.hwp$/i.test(filename) || (bytes.length >= oleSignature.length && oleSignature.every((byte, i) => bytes[i] === byte))) throw new Error(HWP_NOTICE);
+  const zip = readZip(bytes);
+  if (decoder.decode(zip.get('mimetype') ?? new Uint8Array()) !== 'application/hwp+zip') throw new Error('Not an HWPX document');
+  const { paths, paraProps } = sections(zip);
+  const blocks = paths.flatMap(path => children(parseXml(decoder.decode(zip.get(path)!)), 'p').flatMap(p => paragraphMarkdown(p, paraProps)));
+  return blocks.length ? blocks.join('\n\n') + '\n' : '';
+}
+export function markdownToHwpx(markdown: string): Uint8Array {
+  const paragraphs = markdown.replace(/\r\n/g, '\n').trim().split(/\n\s*\n/).filter(Boolean).flatMap(block => {
+    const lines = block.split('\n');
+    if (lines.some(line => /^\|.*\|$/.test(line))) throw new Error('Markdown tables are not supported by the minimal HWPX writer');
+    const result: { style: number; text: string }[] = [];
+    let body: string[] = [];
+    const flush = () => {
+      if (body.length) result.push({ style: 0, text: body.join('\n') });
+      body = [];
+    };
+    for (const line of lines) {
+      const heading = /^(#{1,6}) +(.+)$/.exec(line);
+      if (heading) {
+        flush();
+        result.push({ style: heading[1]!.length, text: heading[2]! });
+      } else body.push(line);
+    }
+    flush();
+    return result;
+  }).map(({ style, text }) => {
+    const content = text.split('\n').map(line => line.split('\t').map(xmlEscape).join('<hp:tab/>')).join('<hp:lineBreak/>');
+    return `<hp:p id="0" paraPrIDRef="${style}" styleIDRef="0" pageBreak="0" columnBreak="0" merged="0"><hp:run charPrIDRef="0"><hp:t>${content}</hp:t></hp:run></hp:p>`;
+  }).join('');
+  const section = `<?xml version="1.0" encoding="UTF-8"?><hs:sec xmlns:hs="${HS}" xmlns:hp="${HP}"><hp:p id="0" paraPrIDRef="0" styleIDRef="0" pageBreak="0" columnBreak="0" merged="0"><hp:run charPrIDRef="0"><hp:secPr id="0" textDirection="HORIZONTAL" spaceColumns="0" tabStop="8000"><hp:pagePr landscape="WIDELY" width="59528" height="84188" gutterType="LEFT_ONLY"/><hp:pageMargin left="5660" right="5660" top="5660" bottom="5660"/></hp:secPr></hp:run></hp:p>${paragraphs}</hs:sec>`;
+  const langs = ['HANGUL', 'LATIN', 'HANJA', 'JAPANESE', 'OTHER', 'SYMBOL', 'USER'];
+  const fonts = langs.map(lang => `<hh:fontface lang="${lang}" fontCnt="1"><hh:font id="0" face="Malgun Gothic" type="TTF" isEmbedded="0"/></hh:fontface>`).join('');
+  const fontRefs = langs.map(lang => `${lang.toLowerCase()}="0"`).join(' ');
+  const charProps = `<hh:charPr id="0" height="1000" textColor="#000000" shadeColor="none" bold="0" italic="0"><hh:fontRef ${fontRefs}/></hh:charPr>`;
+  const paraProps = Array.from({ length: 7 }, (_, i) => `<hh:paraPr id="${i}" tabPrIDRef="0"><hh:heading type="${i ? 'OUTLINE' : 'NONE'}" level="${i ? i - 1 : 0}"/><hh:align horizontal="LEFT" vertical="BASELINE"/></hh:paraPr>`).join('');
+  const header = `<?xml version="1.0" encoding="UTF-8"?><hh:head xmlns:hh="${HH}" version="1.4" secCnt="1"><hh:beginNum page="1" footnote="1" endnote="1" pic="1" tbl="1" equation="1"/><hh:refList><hh:fontfaces itemCnt="1">${fonts}</hh:fontfaces><hh:charProperties itemCnt="1">${charProps}</hh:charProperties><hh:paraProperties itemCnt="7">${paraProps}</hh:paraProperties><hh:styles itemCnt="1"><hh:style id="0" type="PARA" name="Normal" engName="Normal" paraPrIDRef="0" charPrIDRef="0" nextStyleIDRef="0" langID="1042"/></hh:styles></hh:refList></hh:head>`;
+  const content = `<?xml version="1.0" encoding="UTF-8"?><opf:package xmlns:opf="${OPF}" version="1.0"><opf:metadata/><opf:manifest><opf:item id="header" href="header.xml" media-type="application/xml"/><opf:item id="section0" href="section0.xml" media-type="application/xml"/></opf:manifest><opf:spine><opf:itemref idref="header"/><opf:itemref idref="section0"/></opf:spine></opf:package>`;
+  return writeZip([
+    ['mimetype', 'application/hwp+zip'],
+    ['version.xml', '<?xml version="1.0" encoding="UTF-8"?><HWPVersion major="5" minor="0" micro="0" buildNumber="0"/>'],
+    ['META-INF/container.xml', '<?xml version="1.0" encoding="UTF-8"?><container xmlns="urn:oasis:names:tc:opendocument:xmlns:container"><rootfiles><rootfile full-path="Contents/content.hpf" media-type="application/hwpml-package+xml"/></rootfiles></container>'],
+    ['Contents/content.hpf', content], ['Contents/header.xml', header], ['Contents/section0.xml', section],
+  ]);
+}

package/plugins/elanous-hwp/plugin.json

@@ -0,0 +1,16 @@
+{
+  "$schema": "https://antigravity.google/schemas/v1/plugin.json",
+  "name": "elanous-hwp",
+  "version": "0.1.0",
+  "main": "./plugin.ts",
+  "description": "Convert HWPX documents to Markdown and write minimal HWPX from Markdown; legacy HWP is not supported.",
+  "extensions": {
+    "ai.elanous": {
+      "capabilities": ["fs:workdir", "proc:bun"],
+      "connectors": [],
+      "pricing": { "model": "free" },
+      "trust": "official",
+      "category": "Productivity"
+    }
+  }
+}

package/plugins/elanous-hwp/plugin.ts

@@ -0,0 +1,40 @@
+import { readFileSync, writeFileSync } from 'node:fs';
+import type { ElanousPlugin } from '../../src/plugins/core/types.js';
+import { hwpxToMarkdown, markdownToHwpx } from './converter.js';
+
+const plugin: ElanousPlugin = {
+  name: 'elanous-hwp',
+  version: '0.1.0',
+  description: 'Convert HWPX to Markdown and write minimal HWPX from Markdown.',
+  initialState: () => undefined,
+  panes: {},
+  llmTools: [
+    {
+      name: 'HwpxToMarkdown',
+      description: 'Read an HWPX ZIP document as Markdown (paragraphs, headings, tables). Legacy .hwp is unsupported.',
+      parameters: { type: 'object', properties: { path: { type: 'string' } }, required: ['path'] },
+      async handler(args) {
+        const path = args.path;
+        if (typeof path !== 'string') throw new Error('path must be a string');
+        if (/\.hwp$/i.test(path)) throw new Error('HWP(옛 바이너리)는 지원 안 함 · hwpx 로 저장해 달라');
+        if (!/\.hwpx$/i.test(path)) throw new Error('Expected .hwpx input');
+        return { markdown: hwpxToMarkdown(readFileSync(path), path) };
+      },
+    },
+    {
+      name: 'MarkdownToHwpx',
+      description: 'Write paragraphs and headings from a Markdown file to a new HWPX ZIP document.',
+      parameters: { type: 'object', properties: { path: { type: 'string' }, output: { type: 'string' } }, required: ['path', 'output'] },
+      async handler(args) {
+        const { path, output } = args;
+        if (typeof path !== 'string' || typeof output !== 'string') throw new Error('path and output must be strings');
+        if (/\.hwp$/i.test(path) || /\.hwp$/i.test(output)) throw new Error('HWP(옛 바이너리)는 지원 안 함 · hwpx 로 저장해 달라');
+        if (!/\.md$/i.test(path) || !/\.hwpx$/i.test(output)) throw new Error('Expected .md input and .hwpx output');
+        writeFileSync(output, markdownToHwpx(readFileSync(path, 'utf8')), { flag: 'wx' });
+        return { output };
+      },
+    },
+  ],
+};
+
+export default plugin;