elanous 0.2.10 → 0.2.11

package/graphs/release/recipes.yaml

@@ -11,6 +11,9 @@ gate:
   command: 'bun scripts/release-loop/gate-node.ts --json'
   # 4h — the Pod gate took 2h02m on 09-30 (G1f ②) and the 0.2.5 loop was cut at exactly 2h with no verdict; K9 (≤15 min) is the real fix.
   timeout_ms: 14400000
+mac-smoke:
+  command: 'bun scripts/release-loop/mac-smoke-node.ts'
+  timeout_ms: 1800000
 export-check:
   command: 'bun scripts/release-loop/export-check-node.ts'
   timeout_ms: 1800000

package/graphs/release/release-loop.yaml

@@ -15,6 +15,7 @@ nodes:
   - { node_id: cutoff, kind: judge, recipe: 'cmd:cutoff', max_visits: 1 }
   - { node_id: checklist-gate, kind: gate, recipe: 'cmd:checklist-gate', max_visits: 1 }
   - { node_id: gate, kind: gate, recipe: 'cmd:gate', max_visits: 1, notify: start }
+  - { node_id: mac-smoke, kind: gate, recipe: 'cmd:mac-smoke', max_visits: 1 }
   - { node_id: export-check, kind: gate, recipe: 'cmd:export-check', max_visits: 1 }
   - { node_id: pwa, kind: gate, recipe: 'cmd:pwa', max_visits: 1, notify: start }
   - { node_id: prepare, kind: agent, recipe: 'cmd:prepare', max_visits: 1, notify: start }
@@ -37,7 +38,9 @@ edges:
   - { from: version-release, on: outcome, map: { ok: cutoff, fail: failed, error: failed } }
   - { from: cutoff, on: outcome, map: { ok: checklist-gate, fail: failed, error: failed } }
   - { from: checklist-gate, on: outcome, map: { ok: gate, fail: failed, error: failed } }
-  - { from: gate, on: outcome, map: { ok: export-check, fail: failed, error: failed } }
+  - { from: gate, on: outcome, map: { ok: mac-smoke, fail: failed, error: failed } }
+  # Warning-only: a macOS failure or unmeasured run never blocks publishing — auto-approve shows it as a warning row.
+  - { from: mac-smoke, on: outcome, map: { ok: export-check, fail: export-check, error: export-check } }
   - { from: export-check, on: outcome, map: { ok: pwa, fail: failed, error: failed } }
   - { from: pwa, on: outcome, map: { ok: prepare, fail: failed, error: failed } }
   - { from: prepare, on: outcome, map: { ok: upgrade, fail: failed, error: failed } }

package/graphs/video/explainer-line.yaml

@@ -1,7 +1,7 @@
 # «N가지 한 번에 정리» explainer: facts → script → timed VO → composition → checked render → measured QC.
 # Engine = skills/explainer-video (vo.ts · build.mjs). Render/snapshot/check = the existing hyperframes-render recipe.
-# ⚠️ Recipes explainer-script / explainer-vo / explainer-build / explainer-qc are declared here and not yet coded
-#    (src/video-pipeline/recipes) — a walk stops at the first of them as «unknown recipe». Until then the skill runs these steps.
+# Recipes explainer-script / explainer-vo / explainer-build / explainer-qc are implemented in
+# src/video-pipeline/recipes/explainer.ts; the graph routes their outcomes through render and QC.
 graph_id: explainer-line
 version: 1
 entry_node: script

package/package.json

@@ -1,6 +1,7 @@
 {
   "name": "elanous",
-  "version": "0.2.10",
+  "mcpName": "io.github.ElanvitalAI/elanous",
+  "version": "0.2.11",
   "description": "Self-healing coding harness where eyes, hands, and memory all turn on one sentence — it authors its own goals, implements them in isolated worktrees, and reviews its own work.",
   "license": "Apache-2.0",
   "author": "Elanvital AI",

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;

package/scripts/ci-public-export-leak-gate.ts

@@ -3,12 +3,15 @@
  * manifest transforms and private redactions applied, then the leak markers. A hit here fails the next prepare
  * (0.2.7: one test title), so `pr land` and the harness policy gates run it before landing.
  *
- *   bun scripts/ci-public-export-leak-gate.ts --changed-files a b …   # exit 1 on a hit · 0 when clean or not measurable
+ *   bun scripts/ci-public-export-leak-gate.ts --changed-files a b …   # exit 1 on a hit · 0 when clean
  */
 import { spawnSync } from 'node:child_process';
-import { existsSync } from 'node:fs';
-import { join, resolve } from 'node:path';
-import { privateRedactionsPath } from './public-export.js';
+import { existsSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join, relative, resolve } from 'node:path';
+import { stringify } from 'yaml';
+import { computeSkillBoundaries, filterFilesBySkillVerdict } from './skill-boundary.js';
+import { loadExportConfig, privateRedactionsPath, selectExportFiles } from './public-export.js';
 
 export interface ExportLeakCheck {
   readonly measured: boolean;
@@ -16,29 +19,87 @@ export interface ExportLeakCheck {
   readonly detail?: string;
 }
 
-export function exportLeakCheck(changedFiles: readonly string[], root: string): ExportLeakCheck {
+/** Changed source paths that the public manifest would export; unknown skill boundaries remain in scope. */
+export function publicExportChangedFiles(changedFiles: readonly string[], root: string): string[] {
+  const config = loadExportConfig(root);
+  const selected = [...new Set([
+    ...selectExportFiles(changedFiles, config),
+    ...changedFiles.filter((file) => Object.values(config.replace).includes(file)),
+  ])];
+  if (!config.skills || !selected.some((file) => file.startsWith('skills/'))) return selected;
+  try {
+    const boundary = computeSkillBoundaries(root);
+    if (boundary.errors.length) return selected;
+    return filterFilesBySkillVerdict(selected, boundary, config.skills);
+  } catch { return selected; }
+}
+
+export function exportLeakCheck(changedFiles: readonly string[], root: string, spawn: typeof spawnSync = spawnSync): ExportLeakCheck {
   const script = join(root, 'scripts', 'public-export.ts');
   if (!existsSync(script)) return { measured: false, hits: [], detail: 'scripts/public-export.ts 없음' };
   // Without the private table (a Pod, a fresh machine) the markers still run; private identifiers are not checked.
   const privateList = existsSync(privateRedactionsPath()) ? [] : ['--no-private-list'];
-  const r = spawnSync('bun', [script, '--leak-check', '--json', '--all', ...privateList, '--files', ...changedFiles], { cwd: root, encoding: 'utf-8', timeout: 180_000, maxBuffer: 64 * 1024 * 1024 });
+  const args = ['--leak-check', '--json', '--all', ...privateList, '--files', ...changedFiles];
+  const run = (flags: string[]) => spawn('bun', [script, ...flags], { cwd: root, encoding: 'utf-8', timeout: 180_000, maxBuffer: 64 * 1024 * 1024 });
+  const initial = run(args);
+  if (initial.status !== 2) return measuredLeaks(initial);
+
+  const hits = [...String(initial.stderr).matchAll(/^⛔ skill boundary: ([^:\r\n]+):[^\r\n]*$/gm)]
+    .map((match) => ({ file: `skills/${match[1]}/SKILL.md`, line: 1, marker: 'skill-boundary' }));
+  if (!hits.length || !String(initial.stderr).trim().split(/\r?\n/).every((line) => /^⛔ skill boundary: [^:\r\n]+:[^\r\n]*$/.test(line))) {
+    return { measured: false, hits: [], detail: 'rc=2' };
+  }
+
+  // The exporter stops before scanning any changed file on a boundary error. Re-run its
+  // same transforms and leak check with only boundary selection disabled; retain the boundary hits.
+  let dir: string | undefined;
+  try {
+    const config = loadExportConfig(root);
+    dir = mkdtempSync(join(tmpdir(), 'public-export-leak-'));
+    const configPath = join(dir, 'export.yaml');
+    writeFileSync(configPath, stringify({ ...config, skills: undefined }));
+    const measured = measuredLeaks(run(['--config', relative(root, configPath), ...args]));
+    return { ...measured, hits: [...hits, ...measured.hits] };
+  } catch {
+    return { measured: false, hits, detail: 'skill boundary 뒤 재검사 실패' };
+  } finally {
+    if (dir) rmSync(dir, { recursive: true, force: true });
+  }
+}
+
+function measuredLeaks(r: ReturnType<typeof spawnSync>): ExportLeakCheck {
   if (r.status !== 0 && r.status !== 1) return { measured: false, hits: [], detail: `rc=${r.status ?? r.signal}` };
   try {
-    const parsed = JSON.parse(String(r.stdout).trim().split('\n').at(-1) ?? '') as { hits?: Array<{ file: string; line: number; marker: string }> };
-    return { measured: true, hits: (parsed.hits ?? []).map((h) => ({ file: h.file, line: h.line, marker: h.marker })) };
+    const parsed: unknown = JSON.parse(String(r.stdout).trim().split('\n').at(-1) ?? '');
+    if (!parsed || typeof parsed !== 'object' || !('hits' in parsed) || !Array.isArray(parsed.hits)
+      || parsed.hits.some((h: unknown) => !h || typeof h !== 'object'
+        || typeof (h as { file?: unknown }).file !== 'string'
+        || typeof (h as { line?: unknown }).line !== 'number'
+        || typeof (h as { marker?: unknown }).marker !== 'string')) throw new Error('invalid hits');
+    return { measured: true, hits: parsed.hits.map((h: { file: string; line: number; marker: string }) => ({ file: h.file, line: h.line, marker: h.marker })) };
   } catch { return { measured: false, hits: [], detail: 'JSON 을 못 읽었다' }; }
 }
 
-/** Gate form for the harness policy gates: 1 on a hit, 0 when clean or not measurable (said in a line). */
+/** Gate form for the harness policy gates: 1 on a hit, 0 when clean (said in a line). */
 export function runPublicExportLeakGate(io: { args: readonly string[]; cwd: string; log: (line: string) => void; error: (line: string) => void }): number {
   const at = io.args.indexOf('--changed-files');
   const files = at >= 0 ? io.args.slice(at + 1).filter((a) => !a.startsWith('--')) : [];
   if (files.length === 0) return 0;
-  const result = exportLeakCheck(files, io.cwd);
-  if (!result.measured) { io.log(`⚠ public-export-leak: 못 쟀다(${result.detail ?? '?'})`); return 0; }
-  if (result.hits.length === 0) return 0;
-  io.error(`✗ public-export-leak: 바뀐 파일 ${result.hits.length}곳이 공개본에 사적 흔적을 싣는다 — 다음 release prepare 가 여기서 실패한다:`);
-  for (const h of result.hits) io.error(`   ${h.file}:${h.line}  ${h.marker}`);
+  let result: ExportLeakCheck;
+  try { result = exportLeakCheck(files, io.cwd); }
+  catch { result = { measured: false, hits: [], detail: '검사 실행 실패' }; }
+  if (!result.measured) {
+    let publicFiles: string[];
+    try { publicFiles = publicExportChangedFiles(files, io.cwd); }
+    catch { publicFiles = files; }
+    if (publicFiles.length === 0) { io.log('⚠ public-export-leak: 못 쟀다 — 공개 대상 변경 없음'); return 0; }
+    io.error(`✗ public-export-leak: 못 쟀다 — 막는다(${result.detail ?? '?'})`);
+    return 1;
+  }
+  const hits = result.hits.filter((hit) => hit.marker !== 'skill-boundary' || files.includes(hit.file));
+  if (hits.length === 0) return 0;
+  io.error(`✗ public-export-leak: 바뀐 파일 ${hits.length}곳이 공개본에 사적 흔적을 싣는다 — 다음 release prepare 가 여기서 실패한다:`);
+  for (const h of hits) io.error(`   ${h.file}:${h.line} · ${h.marker}`);
   io.error('   그 줄에서 표식·홈 경로·내부 문서 이름을 빼라(주석이면 공개본 변환이 지우는지 bun scripts/public-export.ts --leak-check --files <파일> 로 확인).');
   return 1;
 }

package/scripts/ci-public-leak-gate.ts

@@ -10,8 +10,8 @@
  *   bun scripts/ci-public-leak-gate.ts --changed-files a b …    # 그 파일들만 검사
  *   bun scripts/ci-public-leak-gate.ts --update                 # 기준선 재스냅샷(치운 뒤)
  *
- * ⛔ 이 게이트는 아직 `pr land` 에 «배선하지 않았다» — 다른 트랙의 주석 관례(대표 표기 기호 등)가 매일 늘어 배선 즉시 착지가 막힌다.
- *    배선은 조율 채널 합의 뒤(2026-09-24 🅢).
+ * `pr land` 는 변경 파일을 PR 트리에서 스캔하고 기준선은 base ref 에서 읽어 방향을 경고 전용으로 표시한다.
+ * 단독 CLI 의 기본 기준선은 현재 트리의 파일이며, 증가는 exit 1 이다.
  */
 import { existsSync, readFileSync, writeFileSync } from 'node:fs';
 import { join, resolve } from 'node:path';
@@ -57,6 +57,19 @@ export function renderBaseline(counts: ReadonlyMap<string, number>): string {
 
 export interface LeakGrowth { readonly marker: string; readonly file: string; readonly allowed: number; readonly now: number }
 
+/** 기준선과 현재 트리의 모든 차이(사라진 표지 포함). */
+export function findLeakChanges(current: ReadonlyMap<string, number>, baseline: ReadonlyMap<string, number>, only?: ReadonlySet<string>): LeakGrowth[] {
+  const out: LeakGrowth[] = [];
+  for (const key of new Set([...baseline.keys(), ...current.keys()])) {
+    const [marker, file] = key.split('\t') as [string, string];
+    if (only && !only.has(file)) continue;
+    const allowed = baseline.get(key) ?? 0;
+    const now = current.get(key) ?? 0;
+    if (now !== allowed) out.push({ marker, file, allowed, now });
+  }
+  return out.sort((a, b) => a.file.localeCompare(b.file) || a.marker.localeCompare(b.marker));
+}
+
 /** 기준선보다 «늘어난» (표지, 파일). `only` 가 있으면 그 파일만 본다. */
 export function findGrowth(current: ReadonlyMap<string, number>, baseline: ReadonlyMap<string, number>, only?: ReadonlySet<string>): LeakGrowth[] {
   const out: LeakGrowth[] = [];
@@ -81,6 +94,8 @@ export interface PublicLeakGateIo {
   readonly args?: readonly string[];
   readonly root?: string;
   readonly scan?: () => LeakHit[];
+  /** Read the baseline from the landing base commit, not the PR's working tree. */
+  readonly baselineRef?: string;
   readonly log?: (s: string) => void;
   readonly error?: (s: string) => void;
 }
@@ -100,14 +115,34 @@ export function runPublicLeakGate(io: PublicLeakGateIo = {}): number {
     log(`[public-leak-gate] baseline updated — ${[...current.values()].reduce((a, n) => a + n, 0)} hits · ${current.size} entries`);
     return 0;
   }
-  if (!existsSync(baselinePath)) { error(`[public-leak-gate] FAIL — 기준선이 없다: ${BASELINE_REL} (--update 로 만든다)`); return 2; }
-  const growth = findGrowth(current, parseBaseline(readFileSync(baselinePath, 'utf8')), only);
+  let baselineText: string;
+  if (io.baselineRef) {
+    const shown = spawnSync('git', ['-C', root, 'show', `${io.baselineRef}:${BASELINE_REL}`], { encoding: 'utf8', maxBuffer: 1 << 28 });
+    if (shown.status !== 0) { error(`[public-leak-gate] FAIL — ${io.baselineRef} 기준선을 못 읽었다: ${BASELINE_REL}`); return 2; }
+    baselineText = shown.stdout;
+  } else {
+    if (!existsSync(baselinePath)) { error(`[public-leak-gate] FAIL — 기준선이 없다: ${BASELINE_REL} (--update 로 만든다)`); return 2; }
+    baselineText = readFileSync(baselinePath, 'utf8');
+  }
+  const baseline = parseBaseline(baselineText);
+  const growth = findGrowth(current, baseline, only);
   const scope = only ? `변경 파일 ${only.size}개` : '전체';
-  if (growth.length === 0) { log(`[public-leak-gate] PASS — 유출이 늘지 않았다 (${scope})`); return 0; }
-  error(`[public-leak-gate] FAIL — 유출이 늘었다 (${scope} · ${growth.length}곳):`);
-  for (const g of growth) error(`  ${g.file}  ${g.marker}  ${g.allowed} → ${g.now}`);
-  error('  확인: bun scripts/public-export.ts --leak-check --path <파일> --all');
-  return 1;
+  if (growth.length > 0) {
+    error(`[public-leak-gate] FAIL — 유출이 늘었다 (${scope} · ${growth.length}곳):`);
+    for (const g of growth) error(`  ${g.file}  ${g.marker}  ${g.allowed} → ${g.now}`);
+    error('  확인: bun scripts/public-export.ts --leak-check --path <파일> --all');
+    return 1;
+  }
+  if (io.baselineRef) {
+    const shrunk = findLeakChanges(current, baseline, only).filter((change) => change.now < change.allowed);
+    if (shrunk.length > 0) {
+      log(`[public-leak-gate] SHRANK — 유출이 줄었다 · 기준선 --update 권장 (${scope} · ${shrunk.length}곳):`);
+      for (const g of shrunk) log(`  ${g.file}  ${g.marker}  ${g.allowed} → ${g.now}`);
+      return 3;
+    }
+  }
+  log(`[public-leak-gate] PASS — 유출이 늘지 않았다 (${scope})`);
+  return 0;
 }
 
 if (import.meta.main) process.exit(runPublicLeakGate());

package/scripts/context-hooks/claude-stop.sh

@@ -0,0 +1,4 @@
+#!/usr/bin/env bash
+# Claude Code Stop hook; hook data travels only through stdin to the bounded extractor.
+SCRIPT_DIR="$(CDPATH= cd -- "$(dirname -- "$0")" && pwd)" || exit 0
+bun "$SCRIPT_DIR/emit.ts" stop </dev/stdin >/dev/null 2>&1 || true