elanous 0.2.5 → 0.2.7

package/plugins/geo-check/graphs/run-step.ts

@@ -0,0 +1,198 @@
+import { mkdirSync, mkdtempSync, readFileSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { dirname, join } from 'node:path';
+
+type Data = Record<string, unknown>;
+const object = (v: unknown): Data => v !== null && typeof v === 'object' && !Array.isArray(v) ? v as Data : {};
+const text = (v: unknown): string => typeof v === 'string' ? v.trim() : '';
+const strings = (v: unknown): string[] => Array.isArray(v) ? v.filter((x): x is string => typeof x === 'string' && !!x.trim()) : [];
+const rows = (v: unknown): Data[] => Array.isArray(v) ? v.map(object) : [];
+const line = (v: unknown): string => text(v).replace(/[\r\n|]+/g, ' ');
+const errorLine = (e: unknown): string => line(e instanceof Error ? e.message : String(e)).slice(0, 240) || 'unknown error';
+try {
+const contextPath = process.env.ELANOUS_GRAPH_CONTEXT ?? '';
+const context = object(JSON.parse(readFileSync(contextPath, 'utf8')));
+const input = object(context.input);
+const outputs = object(context.outputs);
+const stateDirectory = dirname(contextPath);
+if (!stateDirectory.endsWith('.json.contexts')) throw new Error('invalid graph run context');
+const defaultOutDir = stateDirectory.slice(0, -'.json.contexts'.length);
+const brand = text(input.brand);
+if (!brand) throw new Error('brand is required');
+const engines = input.engines === undefined ? ['openai-codex', 'grok'] : strings(input.engines);
+if (!engines.length || engines.length > 3 || engines.length !== new Set(engines).size || (input.engines !== undefined && (!Array.isArray(input.engines) || strings(input.engines).length !== input.engines.length))) throw new Error('engines must contain 1 to 3 distinct names');
+const cli = process.env.GEO_CHECK_ELANOUS_BIN || 'elanous';
+
+// Ask from an empty folder: run inside a brand's own repository, `elanous ask` carries that project's
+// context (AGENTS.md and the like) and the answers «know» the brand — a marketer's folder inflated mentions 0/10 → 9/10.
+const neutralDir = mkdtempSync(join(tmpdir(), 'geo-check-'));
+function neutralEnv(engine?: string): Record<string, string | undefined> {
+  const { ELANOUS_TOOL_CWD: _tool, ...rest } = process.env;
+  return { ...rest, PWD: neutralDir, ...(engine ? { ELANOUS_LLM_PROVIDER: engine } : {}) };
+}
+
+async function invoke(args: string[], engine?: string): Promise<unknown> {
+  const proc = Bun.spawn([cli, ...args], {
+    cwd: neutralDir,
+    env: neutralEnv(engine),
+    stdout: 'pipe', stderr: 'pipe',
+  });
+  const [stdout, stderr, exit] = await Promise.all([new Response(proc.stdout).text(), new Response(proc.stderr).text(), proc.exited]);
+  if (exit !== 0) throw new Error(line(stderr || stdout) || `CLI exited ${exit}`);
+  const last = stdout.trim().split('\n').at(-1);
+  if (!last) throw new Error('CLI returned no JSON');
+  return JSON.parse(last) as unknown;
+}
+// An installed elanous older than `ask --bare` rejects the flag; ask the plain way and mark the row so the report can say so.
+async function askEngine(question: string, engine: string): Promise<{ answer: string; bare: boolean }> {
+  try { return { answer: reply(await invoke(['ask', '--bare', '--json', question], engine)), bare: true }; }
+  catch (e) {
+    if (!/unknown option '--bare'/.test(errorLine(e))) throw e;
+    return { answer: reply(await invoke(['ask', '--json', question], engine)), bare: false };
+  }
+}
+function reply(raw: unknown): string {
+  const result = object(raw);
+  if (typeof result.reply !== 'string') throw new Error('ask returned no reply');
+  return result.reply;
+}
+function parseArray(raw: string): unknown {
+  const cleaned = raw.trim().replace(/^```(?:json)?\s*/i, '').replace(/\s*```$/, '');
+  return JSON.parse(cleaned) as unknown;
+}
+function domains(v: string): string {
+  const raw = v.trim().replace(/^https?:\/\//i, '').replace(/^www\./i, '').replace(/\/+$/, '');
+  return raw.split('/')[0]?.toLowerCase().replace(/:\d+$/, '') ?? '';
+}
+function urls(v: unknown): string[] {
+  if (Array.isArray(v)) return v.flatMap(urls);
+  if (typeof v === 'string') return [...v.matchAll(/https?:\/\/[^\s<>"')\]]+/gi)].map(m => m[0]!.replace(/[.,;!?]+$/, ''));
+  if (v && typeof v === 'object') return Object.entries(v).flatMap(([key, item]) => key === 'url' && typeof item === 'string' ? [item] : urls(item));
+  return [];
+}
+// `elanous research --json` = { query, output, metadata } — result links are `- [title](url)` lines in `output`.
+// Only those links count; the query string or other fields may name the brand domain without it being a result.
+function resultUrls(raw: unknown): string[] {
+  const out = object(raw).output;
+  if (typeof out !== 'string') return [];
+  return [...out.matchAll(/^\s*-\s*\[[^\]]*\]\((https?:\/\/[^)\s]+)\)/gm)].map(m => m[1]!);
+}
+// A bare domain in the answer text («see elanous.ai») is a citation too, not only an https:// link.
+function mentionsHost(answer: string, host: string): boolean {
+  if (!host) return false;
+  const escaped = host.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+  return new RegExp(`(^|[^a-z0-9.-])(?:www\\.)?${escaped}(?![a-z0-9-])`, 'i').test(answer);
+}
+function cited(url: string, host: string): boolean {
+  try {
+    const name = new URL(url).hostname.toLowerCase().replace(/^www\./, '');
+    return name === host || name.endsWith(`.${host}`);
+  } catch { return false; }
+}
+function firstMention(answer: string, name: string): number | null {
+  const lower = answer.toLocaleLowerCase();
+  const needle = name.toLocaleLowerCase();
+  let at = lower.indexOf(needle);
+  while (at >= 0) {
+    const before = at ? lower[at - 1]! : '';
+    const after = lower[at + needle.length] ?? '';
+    if (!/[\p{L}\p{N}_]/u.test(before) && !/[\p{L}\p{N}_]/u.test(after)) return at;
+    at = lower.indexOf(needle, at + 1);
+  }
+  return null;
+}
+function output(result: Data, calls = 0, errors = 0): void {
+  console.log(JSON.stringify({ ...result, calls, errors }));
+}
+
+async function run(step: string): Promise<void> {
+  if (step === 'questions') {
+    if (input.questions !== undefined && !Array.isArray(input.questions)) throw new Error('questions must be an array');
+    const provided = strings(input.questions);
+    if (provided.length > 8 || (Array.isArray(input.questions) && provided.length !== input.questions.length)) throw new Error('questions must contain at most 8 nonempty strings');
+    if (provided.length) { output({ questions: provided }); return; }
+    try {
+      const response = reply(await invoke(['ask', '--json', `Generate exactly 5 potential customer questions about the category of ${brand}. Respond ONLY with a JSON array of 5 question strings. Do not include the brand name in any question.`]));
+      const generated = parseArray(response);
+      if (!Array.isArray(generated) || generated.length !== 5 || strings(generated).length !== 5 || strings(generated).some(q => q.toLocaleLowerCase().includes(brand.toLocaleLowerCase()))) throw new Error('ask returned invalid or branded questions');
+      output({ questions: generated }, 1);
+    } catch (e) { output({ outcome: 'fail', questions: [], error: errorLine(e) }, 1, 1); }
+  } else if (step === 'answers') {
+    const questions = strings(object(outputs.questions).questions);
+    if (!questions.length || questions.length > 8) throw new Error('missing questions');
+    const answers: Data[] = [];
+    let failures = 0;
+    for (const question of questions) for (const engine of engines) {
+      try {
+        const { answer, bare } = await askEngine(question, engine);
+        answers.push({ question, engine, answer, ...(bare ? {} : { bare: false }) });
+      }
+      catch (e) { failures++; answers.push({ question, engine, error: errorLine(e) }); }
+    }
+    output({ answers, outcome: failures === answers.length ? 'fail' : 'ok' }, answers.length, failures);
+  } else if (step === 'web') {
+    const questions = strings(object(outputs.questions).questions);
+    const web: Data[] = [];
+    let failures = 0;
+    for (const question of questions) {
+      try { web.push({ question, urls: resultUrls(await invoke(['research', '--json', '--limit', '5', question])).slice(0, 5) }); }
+      catch (e) { failures++; web.push({ question, urls: [], error: errorLine(e) }); }
+    }
+    output({ web }, questions.length, failures);
+  } else if (step === 'score') {
+    const answers = rows(object(outputs.answers).answers);
+    const web = rows(object(outputs.web).web);
+    if (!answers.length) throw new Error('missing answers');
+    const domain = domains(text(input.domain));
+    const table = answers.map(cell => {
+      const answer = text(cell.answer);
+      if (cell.error) return { question: cell.question, engine: cell.engine, error: cell.error, mention: false, citation: domain ? false : null, rank: null };
+      const position = firstMention(answer, brand);
+      const candidates = [...urls(answer), ...strings(web.find(row => row.question === cell.question)?.urls)];
+      return { question: cell.question, engine: cell.engine, mention: position !== null,
+        citation: domain ? candidates.some(url => cited(url, domain)) || mentionsHost(answer, domain) : null, rank: position === null ? null : answer.slice(0, position).trim().split(/\s+/).filter(Boolean).length + 1 };
+    });
+    output({ table }, 0, table.filter(cell => cell.error).length);
+  } else if (step === 'suggest') {
+    const table = rows(object(outputs.score).table);
+    if (!table.length) throw new Error('missing score table');
+    const gaps = table.filter(cell => cell.error || !cell.mention || cell.citation === false).map(cell => ({ question: cell.question, engine: cell.engine, error: cell.error ?? null, mention: cell.mention, citation: cell.citation }));
+    if (!gaps.length) { output({ suggestions: [] }); return; }
+    try {
+      const raw = parseArray(reply(await invoke(['ask', '--json', `Using ONLY this score table, return a JSON array of 3 to 5 improvement suggestions. Each must have "suggestion" (FAQ question, FAQPage/Organization structured data, comparison document, etc.) and "evidence" containing a question and engine from the missing cells. Evidence cells: ${JSON.stringify(gaps)}. Score table: ${JSON.stringify(table)}`])));
+      if (!Array.isArray(raw) || raw.length < 3 || raw.length > 5) throw new Error('invalid suggestion count');
+      const suggestions = raw.map(item => {
+        const candidate = object(item);
+        const evidence = object(candidate.evidence);
+        const match = gaps.find(cell => cell.question === evidence.question && cell.engine === evidence.engine);
+        if (!text(candidate.suggestion) || !match) throw new Error('suggestion missing valid score evidence');
+        return { suggestion: text(candidate.suggestion), evidence: { question: match.question, engine: match.engine } };
+      });
+      output({ suggestions }, 1);
+    } catch (e) { output({ outcome: 'fail', suggestions: [], error: errorLine(e) }, 1, 1); }
+  } else if (step === 'report') {
+    const table = rows(object(outputs.score).table);
+    const answers = rows(object(outputs.answers).answers);
+    const suggestions = rows(object(outputs.suggest).suggestions);
+    if (!table.length) throw new Error('missing score table');
+    const outDir = text(input.outDir) || defaultOutDir;
+    const success = table.filter(cell => !cell.error);
+    const citationSummary = text(input.domain) ? `${success.filter(cell => cell.citation).length}/${success.length} cite ${text(input.domain)}.` : 'Citation unknown (no domain provided).';
+    const summary = `${brand}: ${success.filter(cell => cell.mention).length}/${success.length} available answers mention the brand; ${citationSummary}`;
+    const markdown = [`# GEO check — ${line(brand)}`, '', summary, '', '| Question | Engine | Mention | Citation | Rank | Error |', '| --- | --- | --- | --- | --- | --- |',
+      ...table.map(cell => `| ${line(cell.question)} | ${line(cell.engine)} | ${cell.mention ? 'yes' : 'no'} | ${cell.citation === null ? 'unknown' : cell.citation ? 'yes' : 'no'} | ${cell.rank ?? '—'} | ${line(cell.error)} |`),
+      '', '## Suggestions', ...suggestions.map(item => `- ${line(item.suggestion)} — ${line(object(item.evidence).question)} / ${line(object(item.evidence).engine)}`),
+      '', '## Answers', ...answers.map(cell => `### ${line(cell.question)} — ${line(cell.engine)}\n\n${line(cell.error) || text(cell.answer).slice(0, 400)}\n`), ''].join('\n');
+    mkdirSync(outDir, { recursive: true });
+    const md = join(outDir, 'report.md');
+    const json = join(outDir, 'report.json');
+    writeFileSync(md, markdown, { mode: 0o600 });
+    writeFileSync(json, JSON.stringify({ brand, domain: text(input.domain), summary, table, suggestions, answers }, null, 2) + '\n', { mode: 0o600 });
+    output({ report: md, reportJson: json, summary }, 0, table.filter(cell => cell.error).length);
+  } else throw new Error(`unknown geo-check step: ${step}`);
+}
+
+await run(process.argv[2] ?? '');
+} catch (e) {
+  console.log(JSON.stringify({ outcome: 'fail', error: errorLine(e), calls: 0, errors: 1 }));
+}

package/plugins/geo-check/plugin.json

@@ -0,0 +1,24 @@
+{
+  "$schema": "https://antigravity.google/schemas/v1/plugin.json",
+  "name": "geo-check",
+  "version": "0.1.2",
+  "description": "Measure brand mentions and citations in AI answers and web results.",
+  "extensions": {
+    "ai.elanous": {
+      "graphs": [
+        "./graphs/geo-check.yaml"
+      ],
+      "capabilities": [
+        "fs:workdir",
+        "proc:bun",
+        "proc:elanous"
+      ],
+      "connectors": [],
+      "pricing": {
+        "model": "free"
+      },
+      "trust": "official",
+      "category": "Marketing"
+    }
+  }
+}

package/plugins/job-coach/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "job-coach",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Interview-to-NCS competency gap and cited course report.",
   "skills": "./skills/",
   "contributes": {

package/plugins/job-coach/README.md

@@ -12,11 +12,41 @@
 elanous graph run /absolute/path/to/installed/job-coach/graphs/report-enterprise.yaml --input '{"interview":"/private/path/to/fictional-enterprise.md"}' --json
 ```
 
+### 기업 모드 샘플 입력 (가상 정보만)
+
+다음은 **가상 인물** 민서 하와 **가상 회사** 푸른달 스튜디오의 예시다. 이미지 경로는 실제 사진이 아닌 플레이스홀더이며, 인터뷰 안의 참고용 표기일 뿐이다. 그래프 입력 필드는 `interview` 하나로, 이미지 파일을 읽거나 전송하는 입력은 없다. 비공개 작업 디렉터리에 `fictional-enterprise.md`로 저장한 뒤 위 명령의 `interview` 경로를 그 파일의 절대 경로로 바꾼다.
+
+```markdown
+## 기업 개요
+푸른달 스튜디오 (가상 회사). 이미지 참고 경로: /placeholder/images/fictional-company.png
+
+## 교육 대상
+민서 하 (가상 인물), 문서 기획 담당자
+
+## 현업 과제
+가상 행사 안내 문서의 기획
+
+## 교육 목표
+행사 안내 문서를 요구사항에 맞게 기획한다
+
+## 현재 역량
+문서 작성 경험 (자기보고)
+
+## 교육 제약
+예산과 승인 여부 미확인
+```
+
+### 입력·출력과 프라이버시 경계
+
+입력은 기업 모드 인터뷰 Markdown **파일의 비공개 절대 경로**를 담은 `--input '{"interview":"/private/path/to/fictional-enterprise.md"}'`이다. 위 여섯 `##` 섹션이 필요하다. 실제 직원 이름·사진·인사정보·사내 기밀을 샘플, 명령 인자 또는 공개 저장소에 넣지 않는다. 실제 인터뷰를 사용할 경우에도 민감 정보를 제거하고 접근 제한된 저장소에서만 실행한다. 그래프 러너는 입력·노드 stdout을 런 상태와 컨텍스트 JSON에 저장하므로 **파일 경로만 인자로 넘겨도 보고서와 런 상태에는 인터뷰에서 파생된 직무·역량이 남는다**. 파일 경로가 개인정보 비노출이나 무저장을 보장하는 것은 아니다.
+
+출력은 CLI의 상태 JSON(`statePath`와 `done`/`failed`) 및 그 상태 경로와 같은 디렉터리의 `<run-id>/report.md`다. 보고서는 아래 일곱 섹션으로 구성된다. NCS 조회가 실패하면 `failed`로 끝나며 확인되지 않은 과정·URL 및 내부 승인 여부는 `미확인`으로 남긴다. **No-send boundary:** 이 그래프 실행은 보고서를 로컬에 작성하는 경로이며 메신저·이메일로 보고서를 보내거나 마켓에 게시하는 단계가 없다. `--no-send` 플래그를 지원한다고 가정하지 않는다. 다만 NCS API 조회 및 외부 과정 조사는 네트워크 요청이므로 오프라인·무외부전송 실행이 아니다. 보고서 배포나 마켓 게시/시장 출시는 이 플러그인 README의 범위 밖이다.
+
 기업 보고서는 `기업 개요 및 교육 대상`, `교육 니즈`, `직무·과제 및 NCS`, `AI 적합성`, `역량 진단`, `교육 로드맵`, `교육 명세·운영 경로` 순서다. NCS 조회에 실패하면 매칭을 발명하지 않고 런을 실패로 종료한다. `run-report` 스킬은 개인 보고서 진입이며 기업 모드는 다섯 개 기업 스킬(`enterprise-needs`, `enterprise-task-analysis`, `enterprise-ai-fit`, `enterprise-competency`, `enterprise-roadmap`)과 기업 그래프를 이용한다.
 
 ## 실행
 
-공공데이터포털 [한국산업인력공단 NCS 기준정보 조회](https://www.data.go.kr/data/15128213/openapi.do) 활용신청 후 키를 **환경변수 `NCS_SERVICE_KEY`** 로 설정한다. 설치 시 `credentials` 이벤트의 `ncs.serviceKey` 에 입력하는 경로는 플러그인 설치기가 담당한다. 저장소에는 키를 넣지 않는다. `.mcp.json`은 MCP stdio 서버를 번들로 제공한다. 레시피는 러너가 제공하는 `ELANOUS_GRAPH_DIR`을 기준으로 번들 스크립트를 찾고, MCP의 `${CODEX_PLUGIN_ROOT}`는 Codex가 설치한 플러그인의 절대 경로로 치환한다. 런타임에는 `bun`과 PATH의 `elanous research --json`가 필요하다. 중첩 elanous 호출에는 `--test`를 붙여 격리한다. 인터뷰 파일은 `## 희망 직무`, `## 경험`, `## 보유 역량`을 포함해야 한다.
+공공데이터포털 [한국산업인력공단 NCS 기준정보 조회](https://www.data.go.kr/data/15128213/openapi.do) 활용신청 후 키를 **환경변수 `NCS_SERVICE_KEY`** 로 설정한다. 설치 시 `credentials` 이벤트의 `ncs.serviceKey` 에 입력하는 경로는 플러그인 설치기가 담당한다. 저장소에는 키를 넣지 않는다. `.mcp.json`은 MCP stdio 서버를 번들로 제공한다. 레시피는 러너가 제공하는 `ELANOUS_GRAPH_DIR`을 기준으로 번들 스크립트를 찾고, MCP의 `${CODEX_PLUGIN_ROOT}`는 Codex가 설치한 플러그인의 절대 경로로 치환한다. 런타임에는 `bun`과 PATH의 `elanous research --json`가 필요하다. 중첩 elanous 호출은 그래프를 돌린 우주를 그대로 따른다(`--test` 를 붙이지 않는다 — 저장소 밖에서는 `--test` 가 격리 루트를 못 정해 멈춘다). 인터뷰 파일은 `## 희망 직무`, `## 경험`, `## 보유 역량`을 포함해야 한다.
 
 ```sh
 elanous graph run /absolute/path/to/installed/job-coach/graphs/report.yaml --input '{"interview":"/absolute/path/to/installed/job-coach/examples/interview-sample.md"}' --json

package/plugins/job-coach/graphs/run-step.ts

@@ -230,7 +230,7 @@ async function run(step: string) {
     const profile = value(outputs.profile);
     const query = `${list(profile.jobs).join(' ')} 역량 교육 과정 강의 공식 출처`;
     if (!query.trim()) throw new Error('missing job for research');
-    const cli = Bun.spawn(['elanous', '--test', 'research', query, '--json'], { env: process.env, stdout: 'pipe', stderr: 'pipe' });
+    const cli = Bun.spawn(['elanous', 'research', query, '--json'], { env: process.env, stdout: 'pipe', stderr: 'pipe' });
     const stdout = await new Response(cli.stdout).text();
     const stderr = await new Response(cli.stderr).text();
     if (await cli.exited !== 0) throw new Error(`research failed: ${stderr.slice(0, 300)}`);
@@ -253,7 +253,7 @@ async function run(step: string) {
       return;
     }
     const gaps = await judgeGaps(units, interview, async prompt => {
-      const cli = Bun.spawn(['elanous', '--test', 'ask', '--json', prompt], { env: process.env, stdout: 'pipe', stderr: 'pipe' });
+      const cli = Bun.spawn(['elanous', 'ask', '--json', prompt], { env: process.env, stdout: 'pipe', stderr: 'pipe' });
       const stdout = await new Response(cli.stdout).text();
       await new Response(cli.stderr).text();
       if (await cli.exited !== 0) throw new Error('gap LLM failed');

package/plugins/job-coach/plugin.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://antigravity.google/schemas/v1/plugin.json",
   "name": "job-coach",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Interview-to-NCS competency gap and cited course report.",
   "skills": "./skills/",
   "contributes": {

package/plugins/job-coach/plugin.ts

@@ -1,6 +1,6 @@
 export default {
   name: 'job-coach',
-  version: '0.1.0',
+  version: '0.1.1',
   initialState: () => ({}),
   panes: {},
 };

package/scripts/affinity/endcard.sh

@@ -15,13 +15,14 @@ CFG=$(OUT="$OUT" W="$W" H="$H" T="$TITLE" G="$TAG" F="$FOOT" python3 -c '
 import json, os
 print(json.dumps({"out": os.environ["OUT"], "width": int(os.environ["W"]), "height": int(os.environ["H"]),
                   "title": os.environ["T"], "tagline": os.environ["G"], "footer": os.environ["F"]}))')
-TMP=$(mktemp -t endcard).js
+TMP_DIR=$(mktemp -d "${TMPDIR:-/tmp}/endcard.XXXXXX") || { echo "⛔ 임시 스크립트를 만들지 못했다" >&2; exit 1; }
+TMP="$TMP_DIR/endcard.js"
 CFG="$CFG" python3 -c '
 import os, io, sys
 io.open(sys.argv[2], "w", encoding="utf-8").write(
   io.open(sys.argv[1], encoding="utf-8").read().replace("__CFG__", os.environ["CFG"]))' "$HERE/endcard.js" "$TMP"
 out=$(python3 "$AFF" run "$TMP" 2>&1); rc=$?
-rm -f "$TMP"; echo "$out"
+rm -f "$TMP"; rmdir "$TMP_DIR"; echo "$out"
 printf '%s' "$out" | grep -qE '^Error:|Uncaught|TypeError|ReferenceError' && exit 1
 [ $rc -ne 0 ] && exit 1
 [ -f "$OUT" ] || { echo "⛔ 산출이 «없다»: $OUT" >&2; exit 1; }

package/scripts/affinity/reframe.sh

@@ -37,7 +37,8 @@ print(json.dumps({"src": os.environ["SRC"], "out": os.environ["OUT"],
                   "width": int(os.environ["W"]), "height": int(os.environ["H"]),
                   "blur": float(os.environ["BLUR"]), "mirror": os.environ["MIRROR"] == "1"}))')
 
-TMP=$(mktemp -t reframe).js
+TMP_DIR=$(mktemp -d "${TMPDIR:-/tmp}/reframe.XXXXXX") || { echo "⛔ 임시 스크립트를 만들지 못했다" >&2; exit 1; }
+TMP="$TMP_DIR/reframe.js"
 CFG="$CFG" python3 -c '
 import os, io, sys
 src = io.open(sys.argv[1], encoding="utf-8").read()
@@ -46,6 +47,7 @@ io.open(sys.argv[2], "w", encoding="utf-8").write(src.replace("__CFG__", os.envi
 
 out=$(python3 "$AFF" run "$TMP" 2>&1); rc=$?
 rm -f "$TMP"
+rmdir "$TMP_DIR"
 echo "$out"
 # ⛔ aff.py 는 스크립트 «안»의 오류도 exit 0 으로 낼 수 있다 — 산출을 «읽어서» 가른다.
 if printf '%s' "$out" | grep -qE '^Error:|Uncaught|TypeError|ReferenceError'; then exit 1; fi

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

@@ -0,0 +1,48 @@
+/**
+ * Public export leak check on changed files (LEAK1) — the same check `release prepare` fails on:
+ * 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
+ */
+import { spawnSync } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+import { privateRedactionsPath } from './public-export.js';
+
+export interface ExportLeakCheck {
+  readonly measured: boolean;
+  readonly hits: ReadonlyArray<{ readonly file: string; readonly line: number; readonly marker: string }>;
+  readonly detail?: string;
+}
+
+export function exportLeakCheck(changedFiles: readonly string[], root: string): 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 });
+  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 })) };
+  } 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). */
+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}`);
+  io.error('   그 줄에서 표식·홈 경로·내부 문서 이름을 빼라(주석이면 공개본 변환이 지우는지 bun scripts/public-export.ts --leak-check --files <파일> 로 확인).');
+  return 1;
+}
+
+if (import.meta.main) {
+  process.exit(runPublicExportLeakGate({ args: process.argv.slice(2), cwd: resolve(import.meta.dir, '..'), log: console.log, error: console.error }));
+}