elanous 0.2.5 → 0.2.6

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

@@ -0,0 +1,172 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { dirname, extname, isAbsolute, join } from 'node:path';
+
+type Data = Record<string, unknown>;
+const object = (v: unknown): Data => v && typeof v === 'object' && !Array.isArray(v) ? v as Data : {};
+const text = (v: unknown): string => typeof v === 'string' ? v.trim() : '';
+const fields = ['name', 'title', 'company', 'email', 'phone', 'url', 'linkedin', 'language'] as const;
+const clean = (v: unknown) => text(v) || null;
+const line = (v: unknown) => text(v).replace(/[\r\n|]/g, ' ');
+
+// Find the first balanced object, respecting JSON string escapes and braces in quoted text.
+function firstObject(raw: string): Data {
+  for (let start = raw.indexOf('{'); start !== -1; start = raw.indexOf('{', start + 1)) {
+    let depth = 0, quoted = false, escaped = false;
+    for (let i = start; i < raw.length; i++) {
+      const ch = raw[i];
+      if (quoted) {
+        if (escaped) escaped = false;
+        else if (ch === '\\') escaped = true;
+        else if (ch === '"') quoted = false;
+      } else if (ch === '"') quoted = true;
+      else if (ch === '{') depth++;
+      else if (ch === '}' && --depth === 0) {
+        try {
+          const parsed = JSON.parse(raw.slice(start, i + 1));
+          if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) return parsed as Data;
+        } catch { /* try the next object */ }
+        break;
+      }
+    }
+  }
+  throw new Error(`JSON 객체 없음: ${raw.slice(0, 200)}`);
+}
+
+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)}`);
+  return stdout;
+}
+
+function absolute(path: string, label: string): string {
+  const expanded = path.startsWith('~/') ? join(homedir(), path.slice(2)) : path;
+  if (!isAbsolute(expanded)) throw new Error(`${label}: 절대 경로 필요`);
+  return expanded;
+}
+
+function sources(raw: string): { title: string; url: string; snippet: string }[] {
+  const data = object(JSON.parse(raw));
+  // research --json exposes the human-readable result in `output`.
+  const output = text(data.output);
+  return output.split('\n').flatMap(row => {
+    const match = row.match(/\[([^\]]+)\]\((https?:\/\/[^\s)]+)\)/) ?? row.match(/(https?:\/\/[^\s)]+)/);
+    if (!match) return [];
+    return [{ title: match[2] ? match[1]! : row.replace(match[0], '').trim(), url: match[2] ?? match[1]!, snippet: row.replace(match[0], '').trim() }];
+  });
+}
+
+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 }));
+
+try {
+  if (step === 'read-card') {
+    const image = absolute(text(input.image), 'image');
+    if (!/\.(png|jpe?g|heic)$/i.test(extname(image))) throw new Error('image: png/jpg/heic 필요');
+    if (!existsSync(image)) throw new Error('image: 파일 없음');
+    const raw = await cli(codex, ['exec', '-i', image, '명함 사진에서 읽을 수 있는 값만 JSON 객체로 출력하라: name, title, company, email, phone, url, linkedin, language. 빈 칸은 null. 추측 금지.']);
+    const card = firstObject(raw);
+    const normalized = Object.fromEntries(fields.map(field => [field, clean(card[field])]));
+    result({ card: normalized, image });
+  } else if (step === 'research') {
+    const read = object(outputs['read-card']);
+    const card = object(read.card ?? read);
+    const company = text(card.company), name = text(card.name);
+    if (!company && !name) throw new Error('조사할 이름·회사 없음');
+    const queries = [company || name, [name, company].filter(Boolean).join(' ')];
+    const hits = (await Promise.all(queries.map(query => cli(elanous, ['--test', 'research', '--json', '--limit', '5', query])))).flatMap(sources);
+    const unique = [...new Map(hits.map(hit => [hit.url, hit])).values()];
+    // Only the exact result text may be reported as a company fact, never a model-invented summary.
+    result({ summary: unique.length ? unique[0]!.title : null, news: unique.slice(1, 3).map(hit => hit.title), sources: unique });
+  } else if (step === 'draft') {
+    const read = object(outputs['read-card']);
+    const card = object(read.card ?? read);
+    const research = object(outputs.research);
+    const evidence = (Array.isArray(research.sources) ? research.sources.map(object) : [])
+      .filter(source => /^https?:\/\//.test(text(source.url)));
+    const language = text(input.language) || text(card.language) || 'ko';
+    if (!['ko', 'en'].includes(language)) throw new Error('language: ko 또는 en 필요');
+    const contextLine = text(input.context);
+    const numbered = evidence.map((source, index) => ({ id: `S${index + 1}`, title: text(source.title), snippet: text(source.snippet) }));
+    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, ['--test', 'ask', '--json', JSON.stringify(payload)])) as Data;
+      return firstObject(typeof response.reply === 'string' ? response.reply : JSON.stringify(response));
+    };
+    const instruction = 'JSON 객체만 출력: subject, body (120~200자 · [S#] 표시는 글자 수에서 뺀다), linkedin (300자 이하), question. context가 있으면 body에 그 문구를 그대로 한 번 포함. '
+      + '명함 필드(이름·직함·회사)와 context 는 출처 없이 써도 된다. 그 밖의 회사·사람·시장 사실은 evidence 에 있는 것만 쓰고, 그 문장 끝에 근거 번호를 [S1] 처럼 붙인다. '
+      + 'evidence 에 없는 사실(매출·순위·규모·수상·최근 소식 등)은 쓰지 말 것. email이 없으면 메일 주소를 만들지 말 것. 어떤 메시지도 보내지 말 것.';
+    let feedback = '';
+    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 });
+      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);
+      const shape: string[] = [];
+      if (body.length < 120 || body.length > 200) shape.push(`메일 본문 120~200자 범위 밖(${body.length}자)`);
+      // LinkedIn 한도는 한 번 다시 부르고, 그래도 넘으면 막지 않고 보고서에 경고로 남긴다(보내기 전 사람이 고친다).
+      const linkedinOver = linkedin.length > 300;
+      if (linkedinOver && attempt === 0) shape.push(`LinkedIn 300자 초과(${linkedin.length}자)`);
+      if (contextLine && !body.includes(contextLine)) shape.push('메일 본문에 context 없음');
+      const sentences = Object.values(parts).flatMap(sentencesOf).map(sentence => ({
+        raw: sentence, text: strip(sentence), cites: [...sentence.matchAll(marker)].map(match => Number(match[1])),
+      }));
+      const badCite = sentences.find(sentence => sentence.cites.some(n => n < 1 || n > evidence.length));
+      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({
+        task: 'verify',
+        instruction: '각 문장에 대해, 받는 사람·그 회사·시장에 관한 사실 주장이 명함 필드, context, 또는 그 문장이 인용한 evidence 로 뒷받침되는지 판정하라. 인사·호칭·명함에 있는 이름/회사/직함 언급·제안·질문·보내는 사람의 의도는 사실 주장이 아니다. JSON 객체만 출력: {"unsupported":[뒷받침 안 되는 문장 번호]}',
+        card, context: contextLine,
+        sentences: sentences.map((sentence, i) => ({ i, text: sentence.text, evidence: sentence.cites.map(n => numbered[n - 1]) })),
+      });
+      if (!Array.isArray(verdict.unsupported)) throw new Error('사실 검증 응답을 읽지 못했다');
+      const unsupported = verdict.unsupported.map(Number).filter(i => Number.isInteger(i) && sentences[i]).map(i => sentences[i]!.text);
+      if (unsupported.length) { lastProblem = `출처 없는 회사 사실: ${unsupported.join(' / ')}`; feedback = ` 이전 초안에서 근거 없는 문장: ${unsupported.join(' / ')}. 그 문장을 빼거나 evidence 로 뒷받침되는 문장으로 바꿔라.`; continue; }
+      const facts = sentences.flatMap(sentence => sentence.cites.map(n => ({ text: sentence.text, url: text(evidence[n - 1]!.url) })));
+      accepted = { warnings: linkedinOver ? ['LinkedIn 문구 300자 초과 — 전송 전 수정 필요'] : [], draft: { subject: strip(parts.subject), body, linkedin, question: strip(parts.question) }, facts: [...new Map(facts.map(f => [`${f.text}\n${f.url}`, f])).values()] };
+    }
+    if (!accepted) throw new Error(lastProblem || '초안 생성 실패');
+    result({ ...accepted.draft, companyFacts: accepted.facts, destination: card.email ? ['email', 'LinkedIn'] : ['LinkedIn'], warnings: accepted.warnings, language });
+  } else if (step === 'report') {
+    const read = object(outputs['read-card']);
+    const card = object(read.card ?? read);
+    const research = object(outputs.research), draft = object(outputs.draft);
+    if (!text(draft.subject) || !text(draft.linkedin) || !text(draft.question)) throw new Error('초안 없음');
+    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 hits = Array.isArray(research.sources) ? research.sources.map(object) : [];
+    const warnings = Array.isArray(draft.warnings) ? draft.warnings.map(text).filter(Boolean) : [];
+    const md = ['# 네트워킹 팔로업 초안', '', '## 명함', '| 필드 | 값 |', '| --- | --- |',
+      ...fields.map(field => `| ${field} | ${line(card[field]) || 'null'} |`), '',
+      '## 조사 요약', hits.length ? line(research.summary) : '조사 결과 없음',
+      ...((Array.isArray(research.news) ? research.news : []).map(v => `- ${line(v)}`)),
+      '## 출처', ...(hits.length ? hits.map(hit => `- ${line(hit.title)} — ${text(hit.url)}`) : ['- 조사 결과 없음']), '',
+      '## 보낼 곳', ...((Array.isArray(draft.destination) ? draft.destination : []).map(v => `- ${line(v)}`)), '',
+      '## 팔로업 메일', `제목: ${line(draft.subject)}`, '', text(draft.body), '',
+      '## LinkedIn 초대 문구', text(draft.linkedin), '', '## 대화 이어 갈 질문', text(draft.question), '',
+      '## 초안의 사실과 출처', ...((Array.isArray(draft.companyFacts) && draft.companyFacts.length ? draft.companyFacts : ['출처를 인용한 문장 없음']).map(v => typeof v === 'string' ? `- ${v}` : `- ${line(object(v).text)} — ${text(object(v).url)}`)),
+      ...(warnings.length ? ['## 경고', ...warnings.map(v => `- ${v}`)] : []), '', '※ 초안만 생성했습니다. 전송은 사람이 결정합니다.', ''].join('\n');
+    mkdirSync(outDir, { recursive: true, mode: 0o700 });
+    const report = { card, research, draft, warnings, sent: false };
+    const markdown = join(outDir, 'followup.md'), json = join(outDir, 'followup.json');
+    writeFileSync(markdown, md, { mode: 0o600 });
+    writeFileSync(json, JSON.stringify(report, null, 2) + '\n', { mode: 0o600 });
+    result({ markdown, json });
+  } else throw new Error(`unknown step: ${step}`);
+} catch (error) {
+  result({ outcome: 'fail', reason: error instanceof Error ? error.message : String(error) });
+}

package/plugins/card-followup/plugin.json

@@ -0,0 +1,25 @@
+{
+  "$schema": "https://antigravity.google/schemas/v1/plugin.json",
+  "name": "card-followup",
+  "version": "0.1.0",
+  "description": "Business card photo to researched follow-up and LinkedIn drafts. Drafts are never sent.",
+  "extensions": {
+    "ai.elanous": {
+      "graphs": [
+        "./graphs/card-followup.yaml"
+      ],
+      "capabilities": [
+        "fs:workdir",
+        "proc:bun",
+        "proc:elanous",
+        "proc:codex"
+      ],
+      "connectors": [],
+      "pricing": {
+        "model": "free"
+      },
+      "trust": "official",
+      "category": "Marketing"
+    }
+  }
+}

package/plugins/geo-check/README.md

@@ -0,0 +1,13 @@
+# geo-check
+
+Run from the repository without installing the plugin:
+
+```sh
+elanous graph run plugins/geo-check/graphs/geo-check.yaml --input '{"brand":"Elanous","domain":"elanous.ai"}' --json
+```
+
+Inputs: `brand` (required name), `domain` (optional website; without it, citation is unknown rather than no), `questions` (optional array of up to 8 questions; `[]` generates five unbranded customer questions), `engines` (optional array of up to 3 distinct provider names; defaults to `openai-codex` and `grok`), and `outDir` (optional output directory, default beside the graph run state file). Questions are passed to each engine via `elanous ask --json`, and searched with `elanous research --json --limit 5`. Each step's final stdout line is JSON with `calls` and `errors`. For test fixtures, `GEO_CHECK_ELANOUS_BIN` substitutes the CLI executable.
+
+Outputs: `report.md` has a one-line summary, question × engine mention/citation/rank/error table, evidence-linked suggestions when any question × engine cell is missing a mention or citation (no suggestions when no cells are missing), and the first 400 characters of each answer. `report.json` contains the same data and full answers. One engine can fail while the other completes; if every answer fails, the graph ends at `failed`. Research failures leave empty URL lists and an error count. The table is **a sample at that instant**, not a stable brand ranking: model answers change between runs.
+
+Release note metadata: feat — New geo-check plugin measures whether AI answer engines mention and cite your brand, and suggests fixes · kind: feat · document: plugins/geo-check/README.md · target: next.

package/plugins/geo-check/examples/brand-sample.json

@@ -0,0 +1,8 @@
+{
+  "brand": "Moonfern Atelier",
+  "domain": "moonfern.example",
+  "questions": [
+    "Which studio makes hand-painted stationery for small events?",
+    "Where can I find custom illustrated invitation cards?"
+  ]
+}

package/plugins/geo-check/graphs/geo-check.yaml

@@ -0,0 +1,20 @@
+graph_id: geo-check
+version: 1
+entry_node: questions
+terminal_nodes: [done, failed]
+nodes:
+  - { node_id: questions, kind: agent, recipe: 'cmd:questions', max_visits: 1 }
+  - { node_id: answers, kind: agent, recipe: 'cmd:answers', max_visits: 1 }
+  - { node_id: web, kind: agent, recipe: 'cmd:web', max_visits: 1 }
+  - { node_id: score, kind: agent, recipe: 'cmd:score', max_visits: 1 }
+  - { node_id: suggest, kind: agent, recipe: 'cmd:suggest', max_visits: 1 }
+  - { 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: questions, on: outcome, map: { ok: answers, fail: failed } }
+  - { from: answers, on: outcome, map: { ok: web, fail: failed } }
+  - { from: web, on: outcome, map: { ok: score, fail: failed } }
+  - { from: score, on: outcome, map: { ok: suggest, fail: failed } }
+  - { from: suggest, on: outcome, map: { ok: report, fail: failed } }
+  - { from: report, on: outcome, map: { ok: done, fail: failed } }

package/plugins/geo-check/graphs/recipes.yaml

@@ -0,0 +1,18 @@
+questions:
+  command: 'bun "$ELANOUS_GRAPH_DIR/run-step.ts" questions'
+  timeout_ms: 120000
+answers:
+  command: 'bun "$ELANOUS_GRAPH_DIR/run-step.ts" answers'
+  timeout_ms: 600000
+web:
+  command: 'bun "$ELANOUS_GRAPH_DIR/run-step.ts" web'
+  timeout_ms: 600000
+score:
+  command: 'bun "$ELANOUS_GRAPH_DIR/run-step.ts" score'
+  timeout_ms: 30000
+suggest:
+  command: 'bun "$ELANOUS_GRAPH_DIR/run-step.ts" suggest'
+  timeout_ms: 120000
+report:
+  command: 'bun "$ELANOUS_GRAPH_DIR/run-step.ts" report'
+  timeout_ms: 30000

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

@@ -0,0 +1,177 @@
+import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+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';
+
+async function invoke(args: string[], engine?: string): Promise<unknown> {
+  const proc = Bun.spawn([cli, ...args], {
+    env: { ...process.env, ...(engine ? { ELANOUS_LLM_PROVIDER: 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;
+}
+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 { answers.push({ question, engine, answer: reply(await invoke(['ask', '--json', question], engine)) }); }
+      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.0",
+  "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/README.md

@@ -12,6 +12,36 @@
 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`)과 기업 그래프를 이용한다.
 
 ## 실행

package/scripts/coord-tracks.json

@@ -2,9 +2,9 @@
   "_comment": "조율 채널 세션 신원의 정본(09-30 역할 재편). id = 2글자 신원(발신 접두 **[TC]**) · title = 직함 · alias = 옛 한 글자(기록 읽기·전환기 발신용) · mark = 옛 표지. 세션을 더하려면 여기 한 줄만 더한다 — coord-post.sh · coord-channel-watch.sh · build-docs-site.ts · mission-phase-track.ts 가 이 파일을 읽는다.",
   "tracks": [
     { "id": "OP", "title": "COO", "alias": "S", "mark": "🅢", "owns": ["판올림", "컷", "체크리스트", "분배", "통합", "로드맵", "기획", "총괄", "전략", "인계", "release cut", "roadmap", "plan", "strategy"] },
-    { "id": "MK", "title": "CMO", "alias": "T", "mark": "🅣", "owns": ["블로그", "콘텐츠", "발행", "광고", "프로모션", "소구점", "마케팅", "영상", "비디오", "티저", "하이퍼프레임", "렌더", "blog", "content", "marketing", "ads", "video", "teaser", "render", "B-roll", "상표", "변리사", "브랜드", "trademark", "brand"] },
+    { "id": "MK", "title": "CMO", "alias": "T", "mark": "🅣", "owns": ["블로그", "콘텐츠", "발행", "광고", "프로모션", "소구점", "마케팅", "영상", "비디오", "티저", "하이퍼프레임", "렌더", "blog", "content", "marketing", "ads", "video", "teaser", "render", "B-roll", "상표", "변리사", "브랜드", "trademark", "brand", "홈페이지", "웹사이트", "elanous.ai", "elanvital.ai", "website"] },
     { "id": "TC", "title": "CTO", "alias": "O", "mark": "🅞", "owns": ["하니스", "게이트", "원장", "리뷰", "관측", "릴리스 루프", "흡수", "Obsidian", "매뉴얼", "문서", "기술", "harness", "gate", "ledger", "review", "observability", "intake", "manual", "docs"] },
-    { "id": "UX", "title": "CXO", "alias": "F", "mark": "🅕", "owns": ["PWA", "웹", "웹사이트", "elanous.ai", "탭", "화면", "UI", "프론트엔드", "안드로이드", "아이폰", "데스크톱", "텔레그램", "디스코드", "메신저", "봇", "frontend", "web", "tab", "android", "ios", "desktop", "telegram", "discord", "bot"] },
+    { "id": "UX", "title": "CXO", "alias": "F", "mark": "🅕", "owns": ["PWA", "웹", "탭", "화면", "UI", "프론트엔드", "안드로이드", "아이폰", "데스크톱", "텔레그램", "디스코드", "메신저", "봇", "frontend", "web", "tab", "android", "ios", "desktop", "telegram", "discord", "bot"] },
     { "id": "E", "mark": "🅔", "owns": [] }
   ]
 }

package/scripts/daemon-port-baseline.txt

@@ -1,9 +1,8 @@
 # Daemon port literal baseline: non-comment lines in non-test src/**/*.ts, per file.
 # New files and increases fail. Migrate callers to the daemon endpoint resolver, then --update.
-# total=13 files=6
+# total=12 files=5
 1	src/autopilot/proposal/draft-plan.ts
 6	src/index.ts
-1	src/nexus/api/mcp-oauth-hint.ts
 1	src/nexus/default-port.ts
 2	src/task-orchestrator/surfaces/pod-command-job.ts
 2	src/task-orchestrator/surfaces/self-implement-pod.ts

package/scripts/lib/android-test-device.ts

@@ -0,0 +1,32 @@
+// 계측 시험(`connectedDebugAndroidTest`)을 «어느 기기»에서 돌리나.
+// ⛔ Gradle 은 시험이 끝나면 앱을 «지운다»(데이터까지). 실기기에서 돌면 대표 폰의 앱이 사라진다
+//    (2026-09-30 실측: pr land 의 android-gate 가 USB 로 꽂힌 폴드 8 에서 돌아 설치본이 지워졌다).
+// ⇒ 에뮬레이터(`emulator-*`)만 고른다. 실기기를 쓰려면 serial 을 «명시»해야 한다.
+
+export type TestDevicePick =
+  | { kind: 'use'; serial: string }
+  | { kind: 'skip'; reason: string };
+
+/** `adb devices` 출력에서 «device» 상태인 serial 들. */
+export function attachedSerials(adbDevicesOutput: string): string[] {
+  return adbDevicesOutput
+    .split('\n')
+    .slice(1)
+    .map((line) => line.trim().split(/\s+/))
+    .filter((cols) => cols.length >= 2 && cols[1] === 'device')
+    .map((cols) => cols[0]!);
+}
+
+export function pickInstrumentedTestDevice(adbDevicesOutput: string, explicitSerial?: string): TestDevicePick {
+  const serials = attachedSerials(adbDevicesOutput);
+  if (explicitSerial) {
+    return serials.includes(explicitSerial)
+      ? { kind: 'use', serial: explicitSerial }
+      : { kind: 'skip', reason: `지정한 기기 ${explicitSerial} 가 연결돼 있지 않다` };
+  }
+  const emulator = serials.find((s) => s.startsWith('emulator-'));
+  if (emulator) return { kind: 'use', serial: emulator };
+  return serials.length > 0
+    ? { kind: 'skip', reason: `에뮬레이터가 없다 — 실기기 ${serials.length}대에서는 돌리지 않는다(시험이 앱과 데이터를 지운다) · 실기기를 쓰려면 ELANOUS_ANDROID_TEST_SERIAL=<serial>` }
+    : { kind: 'skip', reason: '연결된 기기·에뮬레이터가 없다' };
+}

package/scripts/release-loop/checklist-gate-node.ts

@@ -0,0 +1,35 @@
+#!/usr/bin/env bun
+import { addItem, checklistGate, listChecklist, summarizeChecklist } from '../../src/release-loop/checklist.js';
+import { emitNodeResult, errorResult, readGraphContext, type GraphContext } from './node-verdict.js';
+
+export function runChecklistGate(context: GraphContext = readGraphContext()) {
+  const version = context.input.version;
+  const data = listChecklist(version);
+  const gate = checklistGate(version);
+  const counts = summarizeChecklist(data);
+  const summary = `확인표 🟢${counts.green} 🟡${counts.yellow}(이동 ${gate.moved.length} · 알려진 문제 ${gate.knownIssues.length} · 막음 ${gate.blocked.length} · 판정 없음 ${gate.undecided.length}) 🔴${counts.red}${gate.red.length ? ` (${gate.red.join(', ')})` : ''}`;
+  if (gate.ok && gate.moved.length) {
+    const [major, minor, patch] = version.split('.').map(Number);
+    const next = `${major}.${minor}.${patch! + 1}`;
+    for (const id of gate.moved) {
+      const item = data.items.find((candidate) => candidate.id === id)!;
+      if (listChecklist(next).items.some((candidate) => candidate.id === id)) continue;
+      try { addItem(next, { id, title: item.title, ...(item.owner !== undefined ? { owner: item.owner } : {}) }); }
+      catch (error) {
+        if (!listChecklist(next).items.some((candidate) => candidate.id === id)) throw error;
+      }
+    }
+  }
+  return { outcome: gate.ok ? 'ok' as const : 'fail' as const, verdict: gate.ok ? 'pass' as const : 'fail' as const, summary, ...gate };
+}
+
+if (import.meta.main) {
+  try {
+    const result = runChecklistGate();
+    emitNodeResult(result);
+    process.exitCode = result.outcome === 'ok' ? 0 : 1;
+  } catch (error) {
+    emitNodeResult(errorResult(error));
+    process.exitCode = 2;
+  }
+}