elanous 0.2.6 → 0.2.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "elanous",
-  "version": "0.2.6",
+  "version": "0.2.7",
   "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",
@@ -11,8 +11,8 @@
   },
   "type": "module",
   "bin": {
-    "elanous": "./bin/elanous.mjs",
-    "eln": "./bin/elanous.mjs"
+    "elanous": "./bin/elanous.cjs",
+    "eln": "./bin/elanous.cjs"
   },
   "engines": {
     "bun": ">=1.3.5"
@@ -111,7 +111,6 @@
     "remark-rehype": "^11.1.2",
     "sharp": "^0.34.5",
     "shiki": "^4.0.2",
-    "telegram": "^2.26.22",
     "typescript": "^5.7.0",
     "unified": "^11.0.5",
     "web-push": "^3.6.7",
@@ -119,7 +118,8 @@
     "yaml": "^2.8.3"
   },
   "optionalDependencies": {
-    "node-pty": "^1.1.0"
+    "node-pty": "^1.1.0",
+    "telegram": "^2.26.22"
   },
   "devDependencies": {
     "@types/bun": "^1.2.0",

package/plugins/card-followup/README.md

@@ -1,6 +1,6 @@
 # card-followup
 
-명함 사진 한 장으로 사람·회사 조사와 팔로업 초안을 만듭니다. 메일과 LinkedIn 메시지는 보내지 않습니다.
+명함 사진 한 장으로 사람·회사 조사, 타겟 판정, 접근 전략, 로컬 CRM 한 줄과 이에 맞는 팔로업 초안을 만듭니다. 메일과 LinkedIn 메시지는 보내지 않습니다.
 
 ## 실행 명령
 
@@ -15,19 +15,28 @@ elanous graph run plugins/card-followup/graphs/card-followup.yaml --input '<json
 - `sender` (선택): 보내는 사람 이름·회사. 기본값은 비움입니다.
 - `language` (선택): `ko` 또는 `en`. 생략하면 명함에서 읽은 언어를 사용합니다.
 - `outDir` (선택): 보고서 출력 절대 경로. 생략하면 그래프 런 디렉터리를 사용합니다.
+- `offer` (선택): 우리 제품과 대상 고객을 설명하는 한두 줄. 없으면 적합도 점수는 `null`, 라벨은 `unknown`이며 접근 전략과 초안은 계속 작성합니다.
+- `crm` (선택): 로컬 CRM CSV의 절대 경로. 기본값은 `<outDir>/crm.csv`입니다.
 
 ## 산출
 
-- `followup.md`: 명함 필드 표, 조사 요약과 출처, 팔로업 메일, LinkedIn 초대 문구, 대화 질문.
-- `followup.json`: 같은 내용의 구조화 데이터. `sent`는 항상 `false`입니다.
+- `followup.md`: 맨 위에 사람·회사 분석, CRM 한 줄, 타겟 판정(점수·라벨·근거), 접근 전략(대상·문제·제안·채널·시점), 메일·LinkedIn 초안을 순서대로 보여줍니다. 그 아래에 출처와 경고가 있습니다.
+- `followup.json`: `fit`, `approach`, `nextAction`, `crm` 경로 및 초안의 구조화 데이터. `sent`는 항상 `false`입니다. 타겟 판정의 `S#` 이유는 번호뿐 아니라 해당 출처의 제목·본문 조각과 주장 내용도 재검증합니다. `assumption`은 적합성 근거로 세지 않고, 실제 명함·만남 맥락·제안·조사 출처에 뒷받침되는 이유만 남깁니다. 재작성 후에도 유효한 이유가 두 개 미만이면 점수는 `null`, 라벨은 `unknown`입니다. 접근 전략은 주장별 근거와 전체 출처 원문을 대조하고, 다음 행동의 확인되지 않은 고객 약속·확정 일정은 재작성 후에도 남으면 산출을 중단합니다. 다음 행동·기한은 제안 또는 내부 목표이지 고객 확약이 아닙니다.
+- `crm.csv` (또는 지정한 `crm` 경로): `name,company,title,email,interest,met_context,fit_score,fit_label,next_action,due,updated_at` 헤더의 로컬 CSV. 같은 이메일(없으면 이름+회사)은 갱신하고 다른 연락처는 추가합니다. 적합도 점수 내림차순으로 저장하며 미판정 점수는 맨 뒤입니다. 쉼표·따옴표·줄바꿈이 포함된 값은 CSV 인용 규칙으로 저장합니다. 외부 CRM과 동기화하지 않습니다.
 
 ## 개인정보 주의
 
 명함 사진과 연락처는 그래프 런 상태에 남습니다. 비공개 경로만 사용하고 공유하지 마세요.
 
+어디로 나가나:
+- **명함 이미지** → `codex`(설치된 codex CLI 의 모델)가 읽는다.
+- **이름·회사·사이트** → `elanous research` 가 웹 검색어로 쓴다.
+- **명함 필드·만남 맥락·offer·조사 결과** → `elanous ask` 로 설정된 LLM 에 보내 판정·전략·초안을 만든다.
+- **CRM(`crm.csv`)·보고서** → 이 기계의 파일에만 쓴다. 외부 CRM 과 동기화하지 않고, 메일·LinkedIn 을 보내지 않는다.
+
 ## 릴리스 노트
 
-- 한 줄: feat — New card-followup plugin turns a business card photo into researched follow-up and LinkedIn drafts
+- 한 줄: feat — card-followup turns one business card into a sales plan: a local CRM row sorted by fit, a target-fit score with three sourced reasons, an approach strategy and matching drafts, all on one report
 - 종류: feat
 - 문서: plugins/card-followup/README.md
 - 대상: next

package/plugins/card-followup/graphs/card-followup.yaml

@@ -5,12 +5,14 @@ terminal_nodes: [done, failed]
 nodes:
   - { node_id: read-card, kind: agent, recipe: 'cmd:read-card', max_visits: 1 }
   - { node_id: research, kind: agent, recipe: 'cmd:research', max_visits: 1 }
+  - { node_id: strategy, kind: agent, recipe: 'cmd:strategy', max_visits: 1 }
   - { node_id: draft, kind: agent, recipe: 'cmd:draft', 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: read-card, on: outcome, map: { ok: research, fail: failed } }
-  - { from: research, on: outcome, map: { ok: draft, fail: failed } }
+  - { from: research, on: outcome, map: { ok: strategy, fail: failed } }
+  - { from: strategy, on: outcome, map: { ok: draft, fail: failed } }
   - { from: draft, on: outcome, map: { ok: report, fail: failed } }
   - { from: report, on: outcome, map: { ok: done, fail: failed } }

package/plugins/card-followup/graphs/recipes.yaml

@@ -4,9 +4,13 @@ read-card:
 research:
   command: 'bun "$ELANOUS_GRAPH_DIR/run-step.ts" research'
   timeout_ms: 120000
+# strategy·draft make up to four LLM calls (write ⊕ verify, one retry) — 61–80 s clean, a retry doubles it (10-01 live: 120 s timeout hit).
+strategy:
+  command: 'bun "$ELANOUS_GRAPH_DIR/run-step.ts" strategy'
+  timeout_ms: 300000
 draft:
   command: 'bun "$ELANOUS_GRAPH_DIR/run-step.ts" draft'
-  timeout_ms: 120000
+  timeout_ms: 300000
 report:
   command: 'bun "$ELANOUS_GRAPH_DIR/run-step.ts" report'
   timeout_ms: 30000

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

@@ -1,6 +1,7 @@
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
 import { homedir } from 'node:os';
-import { dirname, extname, isAbsolute, join } from 'node:path';
+import { dirname, extname, isAbsolute, join, basename } from 'node:path';
+import { buildStrategy, crmRow, upsertCrm } from './sales-strategy.js';
 
 type Data = Record<string, unknown>;
 const object = (v: unknown): Data => v && typeof v === 'object' && !Array.isArray(v) ? v as Data : {};
@@ -46,6 +47,28 @@ function absolute(path: string, label: string): string {
   return expanded;
 }
 
+// The page's own <title> and meta/og description — the company's words about itself. 5 s cap; null on any failure.
+async function readPage(url: string): Promise<{ title: string; description: string } | null> {
+  try {
+    const res = await fetch(url, { signal: AbortSignal.timeout(5000), redirect: 'follow', headers: { 'user-agent': 'Mozilla/5.0 card-followup' } });
+    if (!res.ok || !(res.headers.get('content-type') ?? '').includes('html')) return null;
+    const html = (await res.text()).slice(0, 200_000);
+    const decode = (v: string) => v.replace(/&amp;/g, '&').replace(/&lt;/g, '<').replace(/&gt;/g, '>').replace(/&quot;/g, '"').replace(/&#39;/g, "'").replace(/\s+/g, ' ').trim();
+    const meta = (key: string) => {
+      for (const tag of html.match(/<meta\b[^>]*>/gi) ?? []) {
+        if (new RegExp(`(?:name|property)=["']${key}["']`, 'i').test(tag)) {
+          const content = /content=["']([^"']*)["']/i.exec(tag)?.[1];
+          if (content) return decode(content);
+        }
+      }
+      return '';
+    };
+    const title = decode(/<title[^>]*>([\s\S]*?)<\/title>/i.exec(html)?.[1] ?? '') || meta('og:title');
+    const description = meta('description') || meta('og:description');
+    return title && description ? { title, description } : null;
+  } catch { return null; }
+}
+
 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`.
@@ -53,6 +76,8 @@ function sources(raw: string): { title: string; url: string; snippet: string }[]
   return output.split('\n').flatMap(row => {
     const match = row.match(/\[([^\]]+)\]\((https?:\/\/[^\s)]+)\)/) ?? row.match(/(https?:\/\/[^\s)]+)/);
     if (!match) return [];
+    // A logo or thumbnail row («[![](…)](…png)») is not a source.
+    if (/^\s*[-*]?\s*\[?!\[/.test(row) || /\.(?:png|jpe?g|gif|svg|webp)(?:[?#]|$)/i.test(match[2] ?? match[1]!)) return [];
     return [{ title: match[2] ? match[1]! : row.replace(match[0], '').trim(), url: match[2] ?? match[1]!, snippet: row.replace(match[0], '').trim() }];
   });
 }
@@ -72,7 +97,9 @@ try {
     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. 추측 금지.']);
+    // The prompt goes before `-i`: `--image` takes several files, so a prompt after it is read as another image
+    // and codex answers «No prompt provided» (10-01 live run). The graph may run outside a git checkout.
+    const raw = await cli(codex, ['exec', '--skip-git-repo-check', '명함 사진에서 읽을 수 있는 값만 JSON 객체로 출력하라: name, title, company, email, phone, url, linkedin, language(ko 또는 en). 빈 칸은 null. 추측 금지.', '-i', image]);
     const card = firstObject(raw);
     const normalized = Object.fromEntries(fields.map(field => [field, clean(card[field])]));
     result({ card: normalized, image });
@@ -81,18 +108,74 @@ try {
     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);
+    // The card's own site is the strongest query: «Elanvital AI» alone ranks vital.ai and elanvital.co above elanvital.ai
+    // (10-01 dry run: 19 hits, none from the company), while «elanvital.ai» returns the site itself.
+    const siteQuery = text(card.url).replace(/^https?:\/\//, '').replace(/^www\./, '').split('/')[0]!.toLowerCase();
+    const queries = [...new Set([...(siteQuery.includes('.') ? [siteQuery] : []), company || name, [name, company].filter(Boolean).join(' ')])];
+    const hits = (await Promise.all(queries.map(query => cli(elanous, ['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 });
+    // Put results that name the card's company (or its site) first; if none does, say nothing as a summary —
+    // the first search hit was another company's page on the 10-01 live run («Vital AI» for Elanvital AI).
+    const site = text(card.url).replace(/^https?:\/\//, '').replace(/^www\./, '').split('/')[0]!.toLowerCase();
+    const companyKey = company.toLowerCase().replace(/[^a-z0-9가-힣]/g, '');
+    const squash = (value: string) => value.toLowerCase().replace(/[^a-z0-9가-힣]/g, '');
+    const nameKey = squash(name);
+    const hostOf = (url: string) => { try { return new URL(url).hostname.toLowerCase().replace(/^www\./, ''); } catch { return ''; } };
+    // The site counts by host («vercel.com», «docs.vercel.com»), never by substring — «someone.vercel.app» is a stranger's page.
+    // The company counts by title only, and a title carrying the contact's name counts only on the company's own site:
+    // a search cannot tell this Alex Rivera from another.
+    const matches = (hit: { title: string; url: string }) => {
+      const host = hostOf(hit.url);
+      const onSite = !!site && (host === site || host.endsWith(`.${site}`));
+      if (onSite) return true;
+      // A bare-link row has the link as its «title» — that is a host, not a name.
+      const title = /^https?:\/\//i.test(hit.title.trim()) ? '' : squash(hit.title);
+      if (nameKey.length >= 3 && title.includes(nameKey)) return false;
+      return companyKey.length >= 3 && title.includes(companyKey);
+    };
+    // Only hits that name the card's company or site are kept: a name search also returns other people with the
+    // same name (10-01 live run: strangers' LinkedIn, Instagram and IMDb pages listed as this contact's sources).
+    // A site hit often comes back as a bare link with no title or snippet («https://elanvital.ai» · «-»): nothing a
+    // strategy can cite, and the verifier rejects claims resting on it (10-01 dry run: strategy failed twice on «who»).
+    // Read the page's own <title> and description once instead, and keep one row per host.
+    const thin = (hit: { title: string }) => /^https?:\/\//i.test(hit.title.trim()) || hostOf(`https://${hit.title.trim()}`) === hit.title.trim().toLowerCase();
+    const seenHost = new Set<string>();
+    const relevant: { title: string; url: string; snippet: string }[] = [];
+    for (const hit of unique.filter(matches)) {
+      const host = hostOf(hit.url);
+      if (!thin(hit)) { relevant.push(hit); continue; }
+      if (seenHost.has(host)) continue;
+      seenHost.add(host);
+      const page = await readPage(hit.url);
+      if (page) relevant.push({ title: page.title, url: hit.url, snippet: page.description });
+    }
+    result({ summary: relevant.length ? relevant[0]!.title : null, news: relevant.slice(1, 3).map(hit => hit.title), sources: relevant, dropped: unique.length - relevant.length });
+  } else if (step === 'strategy') {
+    const read = object(outputs['read-card']);
+    const card = object(read.card ?? read);
+    const research = object(outputs.research);
+    const ask = async (payload: Data): Promise<Data> => {
+      const response = JSON.parse(await cli(elanous, ['ask', '--json', JSON.stringify(payload)])) as Data;
+      return firstObject(typeof response.reply === 'string' ? response.reply : JSON.stringify(response));
+    };
+    const strategy = await buildStrategy({ card, research, context: text(input.context), offer: text(input.offer), ask });
+    const fallback = dirname(contextFile).endsWith('.json.contexts') ? dirname(contextFile).slice(0, -'.json.contexts'.length) : dirname(contextFile);
+    const outDir = input.outDir === undefined ? fallback : absolute(text(input.outDir), 'outDir');
+    const crm = input.crm === undefined ? join(outDir, 'crm.csv') : absolute(text(input.crm), 'crm');
+    const row = crmRow(card, strategy.fit, strategy.approach, strategy.nextAction, text(input.context), new Date());
+    upsertCrm(crm, row);
+    result({ ...strategy, crm, crmRow: row });
   } else if (step === 'draft') {
     const read = object(outputs['read-card']);
     const card = object(read.card ?? read);
     const research = object(outputs.research);
+    const approach = object(object(outputs.strategy).approach);
     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';
+    // A card reader may answer «English»/«Korean»/«한국어» — fold them to the two codes the draft step writes in.
+    const languageCode = (value: string) => ({ english: 'en', en: 'en', korean: 'ko', ko: 'ko', '한국어': 'ko', '영어': 'en' } as Record<string, string>)[value.toLowerCase()] ?? value;
+    const language = languageCode(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) }));
@@ -100,17 +183,24 @@ try {
     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;
+      const response = JSON.parse(await cli(elanous, ['ask', '--json', JSON.stringify(payload)])) as Data;
       return firstObject(typeof response.reply === 'string' ? response.reply : JSON.stringify(response));
     };
-    const instruction = 'JSON 객체만 출력: subject, body (120~200자 · [S#] 표시는 글자 수에서 뺀다), linkedin (300자 이하), question. context가 있으면 body에 그 문구를 그대로 한 번 포함. '
+    // A Korean meeting note on an English card used to be pasted verbatim into the English mail
+    // («Hi Joosung, 마케터의 밤에서 인사.» · 10-01 dry run). Across languages the note is translated, not copied.
+    const crossLanguage = language === 'en' && /[가-힣]/.test(contextLine);
+    const contextRule = crossLanguage
+      ? 'context 는 한국어 메모다 — 원문을 그대로 넣지 말고 영어로 옮겨 body 에서 한 번 언급하라. subject·body·linkedin·question 에 한글을 쓰지 말 것. '
+      : 'context가 있으면 body에 그 문구를 그대로 한 번 포함. ';
+    const instruction = 'JSON 객체만 출력: subject, body (120~200자 · [S#] 표시는 글자 수에서 뺀다), linkedin (300자 이하), question. ' + contextRule
       + '명함 필드(이름·직함·회사)와 context 는 출처 없이 써도 된다. 그 밖의 회사·사람·시장 사실은 evidence 에 있는 것만 쓰고, 그 문장 끝에 근거 번호를 [S1] 처럼 붙인다. '
+      + 'approach.problem·proposal·channel 에 맞춰 메일과 LinkedIn 초안을 작성하되, 전략 문구도 회사·사람·시장 사실이면 위의 문장별 근거 규칙을 반드시 따를 것. '
       + '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 draft = await ask({ task: 'draft', instruction: instruction + feedback, card, context: contextLine, sender: text(input.sender), language, evidence: numbered, approach: { problem: text(approach.problem), proposal: text(approach.proposal), channel: text(approach.channel) } });
       const 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);
@@ -119,7 +209,8 @@ try {
       // LinkedIn 한도는 한 번 다시 부르고, 그래도 넘으면 막지 않고 보고서에 경고로 남긴다(보내기 전 사람이 고친다).
       const linkedinOver = linkedin.length > 300;
       if (linkedinOver && attempt === 0) shape.push(`LinkedIn 300자 초과(${linkedin.length}자)`);
-      if (contextLine && !body.includes(contextLine)) shape.push('메일 본문에 context 없음');
+      if (contextLine && !crossLanguage && !body.includes(contextLine)) shape.push('메일 본문에 context 없음');
+      if (crossLanguage && /[가-힣]/.test([parts.subject, body, linkedin, parts.question].join(' '))) 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])),
       }));
@@ -144,24 +235,37 @@ try {
   } 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);
+    const research = object(outputs.research), draft = object(outputs.draft), strategy = object(outputs.strategy);
+    const fit = object(strategy.fit), approach = object(strategy.approach), nextAction = object(strategy.nextAction);
     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)}`)),
+    const crm = text(strategy.crm);
+    const row = object(strategy.crmRow);
+    if (!crm || !Array.isArray(fit.reasons) || !text(approach.who) || !text(approach.problem)
+      || !text(approach.proposal) || !text(approach.channel) || !text(approach.timing)
+      || !text(nextAction.what) || !text(nextAction.due) || !('fit_label' in row)) throw new Error('전략 없음');
+    const md = ['# 명함 영업 계획', '', '## ① 사람·회사 분석',
+      `${line(card.name) || '이름 없음'} · ${line(card.title) || '직함 없음'} · ${line(card.company) || '회사 없음'} · ${line(card.email) || '이메일 없음'}`,
+      `조사 요약: ${hits.length ? line(research.summary) : '조사 결과 없음'}`, '',
+      '## ② CRM 한 줄', `파일: ${basename(crm)}`, Object.entries(row).map(([key, value]) => `${key}: ${line(value)}`).join(' · '), '',
+      '## ③ 타겟 판정', `점수: ${fit.score === null ? 'null' : String(fit.score)} · 라벨: ${line(fit.label)}`,
+      ...(fit.reasons as unknown[]).map(v => `- ${line(object(v).text)} (${line(object(v).basis)})`), '',
+      '## ④ 접근 전략', `- 누구에게: ${line(approach.who)}`, `- 어떤 문제: ${line(approach.problem)}`,
+      `- 어떤 제안: ${line(approach.proposal)}`, `- 어느 채널: ${line(approach.channel)}`, `- 언제: ${line(approach.timing)}`,
+      `- 다음 행동: ${line(nextAction.what)} · 기한: ${line(nextAction.due)}`, '',
+      '## ⑤ 메일·LinkedIn 초안', '### 팔로업 메일', `제목: ${line(draft.subject)}`, '', text(draft.body), '',
+      '### LinkedIn 초대 문구', text(draft.linkedin), '', '### 대화 이어 갈 질문', text(draft.question), '',
+      '## 명함 전체 필드', '| 필드 | 값 |', '| --- | --- |', ...fields.map(field => `| ${field} | ${line(card[field]) || 'null'} |`), '',
+      '## 추가 조사 결과', ...((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 report = { card, research, fit, approach, nextAction, crm, 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 });

package/plugins/card-followup/graphs/sales-strategy.ts

@@ -0,0 +1,173 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { dirname } from 'node:path';
+
+type Data = Record<string, unknown>;
+const object = (value: unknown): Data => value && typeof value === 'object' && !Array.isArray(value) ? value as Data : {};
+const text = (value: unknown): string => typeof value === 'string' ? value.trim() : '';
+
+type Fit = {
+  score: number | null;
+  label: 'high' | 'medium' | 'low' | 'unknown';
+  reasons: { text: string; basis: string }[];
+};
+type Approach = { who: string; problem: string; proposal: string; channel: string; timing: string };
+type NextAction = { what: string; due: string };
+type Strategy = { fit: Fit; approach: Approach; nextAction: NextAction };
+type CrmRow = Record<(typeof columns)[number], string>;
+const columns = ['name', 'company', 'title', 'email', 'interest', 'met_context', 'fit_score', 'fit_label', 'next_action', 'due', 'updated_at'] as const;
+
+function parseAnswer(raw: unknown): Data {
+  const response = object(raw);
+  if (typeof response.reply === 'string') {
+    const reply = response.reply;
+    const start = reply.indexOf('{'), end = reply.lastIndexOf('}');
+    if (start < 0 || end < start) throw new Error('strategy 응답 JSON 객체 없음');
+    return object(JSON.parse(reply.slice(start, end + 1)));
+  }
+  return response;
+}
+
+async function defaultAsk(payload: Data): Promise<unknown> {
+  const child = Bun.spawn(['elanous', 'ask', '--json', JSON.stringify(payload)], { 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(`ask 실패: ${(stderr || stdout).slice(0, 200)}`);
+  return JSON.parse(stdout);
+}
+
+export async function buildStrategy({ card, research, context = '', offer = '', ask = defaultAsk }: {
+  card: Data; research: Data; context?: string; offer?: string; ask?: (payload: Data) => Promise<unknown>;
+}): Promise<Strategy> {
+  const sources = Array.isArray(research.sources) ? research.sources.map(object).filter(source => /^https?:\/\//.test(text(source.url))) : [];
+  const evidence = sources.map((source, i) => ({ id: `S${i + 1}`, title: text(source.title), snippet: text(source.snippet), url: text(source.url) }));
+  const hasOffer = !!text(offer);
+  const sourceBasis = (basis: string) => /^S[1-9]\d*$/.test(basis) && Number(basis.slice(1)) <= evidence.length
+    && !!(evidence[Number(basis.slice(1)) - 1]?.title || evidence[Number(basis.slice(1)) - 1]?.snippet);
+  const fitBasis = (basis: string) => basis === 'card' && Object.values(card).some(value => !!text(value))
+    || basis === 'context' && !!text(context) || basis === 'offer' && hasOffer || sourceBasis(basis);
+  const validBasis = (basis: string) => basis === 'assumption' || fitBasis(basis);
+  const citedEvidence = (basis: string) => /^S\d+$/.test(basis) ? evidence[Number(basis.slice(1)) - 1] : undefined;
+  const instruction = 'JSON 객체만 출력: {"fit":{"score":0~100,"label":"high|medium|low","reasons":[{"text":"이유","basis":"S1|card|context|offer"} 3개]},"approach":{"who":"누구에게","problem":"어떤 문제","proposal":"어떤 제안","channel":"어느 채널","timing":"언제"},"approachBasis":{"who":["card"],"problem":["S1"],"proposal":["offer"],"channel":["assumption"],"timing":["assumption"]},"nextAction":{"what":"할 일","due":"기한"},"nextActionBasis":{"what":["assumption"],"due":["assumption"]}}. approachBasis와 nextActionBasis에는 각 필드의 주장에 실제로 사용한 근거 번호/입력을 적을 것. S#는 제공된 evidence 번호만 사용. nextAction은 고객의 확정 약속이나 확정 일정을 주장하지 말고 우리가 제안할 내부 행동과 목표 기한으로만 작성할 것. 출처에 없는 사실을 꾸며내지 말 것. offer가 없으면 fit 평가는 하지 말고 명함과 만남 맥락만으로 접근 전략을 작성할 것. 메시지는 보내지 말 것. 전략은 구체적이어야 한다(일반론 «AI 로 효율화» 금지): who = 이름·직함 ⊕ 결정권 추정(추정이면 basis 에 assumption); problem = 그 회사가 지금 겪을 법한 문제 하나 — 근거는 출처 S# 또는 만남 맥락(context)이어야 하고 없으면 만남 맥락에서 나온 관심사로 좁힌다; proposal = 우리 제안 하나(수치 약속 없음 · 작은 시범·시연·파일럿처럼 바로 해 볼 수 있는 것); channel = 메일/LinkedIn/전화 중 하나 ⊕ 그 이유 한 구; timing = 날짜나 요일로(예: 행사 다음 날 오전 · 이번 주 금요일 전). fit 이유는 서로 다른 근거로 셋을 채워라(card·context·offer·S#).';
+  let answer: Data = {};
+  let reasons: Fit['reasons'] = [];
+  let feedback = '';
+  // Three tries: with company-site evidence the writer still over-cites about one run in three (10-01 dry runs 0.2.6–0.2.8);
+  // the third try gets the rejected fields by name. The verdict rule itself is unchanged.
+  const LAST = 2;
+  for (let attempt = 0; attempt <= LAST; attempt++) {
+    try {
+      answer = parseAnswer(await ask({ task: 'strategy', instruction: instruction + feedback, card, research: hasOffer ? { summary: research.summary, news: research.news } : {}, context, offer, evidence: hasOffer ? evidence : [] }));
+    } catch (error) {
+      if (attempt >= 1) throw error;
+      feedback = ' 이전 답이 올바른 JSON 객체가 아니었다. 지정한 필드를 갖춘 JSON 객체만 다시 작성하라.';
+      continue;
+    }
+    const approachData = object(answer.approach);
+    const actionData = object(answer.nextAction);
+    if ((['who', 'problem', 'proposal', 'channel', 'timing'] as const).some(field => !text(approachData[field]))
+      || !text(actionData.what) || !text(actionData.due)) {
+      if (attempt >= 1) throw new Error('접근 전략 필수 필드 없음');
+      feedback = ' 이전 답에 접근 전략 또는 다음 행동 필수 필드가 빠졌다. 모두 채워 다시 작성하라.';
+      continue;
+    }
+    const raw = hasOffer && Array.isArray(object(answer.fit).reasons) ? object(answer.fit).reasons as unknown[] : [];
+    reasons = raw.map(object).map(item => ({ text: text(item.text), basis: text(item.basis) }))
+      .filter(item => item.text && fitBasis(item.basis)).slice(0, 3);
+    const invalidNumber = raw.some(item => !text(object(item).text) || !fitBasis(text(object(item).basis)));
+    const claims = reasons.map((reason, i) => ({ i, text: reason.text, basis: reason.basis, evidence: citedEvidence(reason.basis) }));
+    const basisFor = (rawBasis: unknown) => {
+      const entries = Array.isArray(rawBasis) ? rawBasis : [];
+      return entries.map(text).filter(validBasis);
+    };
+    const approachBasis = object(answer.approachBasis), actionBasis = object(answer.nextActionBasis);
+    const approachClaims = (['who', 'problem', 'proposal', 'channel', 'timing'] as const)
+      .map(field => ({ field, text: text(approachData[field]), basis: basisFor(approachBasis[field]),
+        evidence: basisFor(approachBasis[field]).map(citedEvidence).filter((source): source is NonNullable<typeof source> => !!source) }));
+    const actionClaims = (['what', 'due'] as const)
+      .map(field => ({ field, text: text(actionData[field]), basis: basisFor(actionBasis[field]),
+        evidence: basisFor(actionBasis[field]).map(citedEvidence).filter((source): source is NonNullable<typeof source> => !!source) }));
+    const invalidClaims = [...approachClaims.map(claim => ({ claim, raw: approachBasis[claim.field] })),
+      ...actionClaims.map(claim => ({ claim, raw: actionBasis[claim.field] }))]
+      .some(({ claim, raw }) => !Array.isArray(raw) || !claim.basis.length || raw.length !== claim.basis.length ||
+        (!hasOffer && claim.basis.some(basis => /^S\d+$/.test(basis))));
+    const verdict = parseAnswer(await ask({ task: 'strategy-verify',
+      instruction: 'fit 이유는 사실 주장뿐 아니라 적합성 판단 자체도 그 이유에 표시된 basis의 실제 내용(명함 필드·만남 맥락·제안·인용된 출처 제목/본문 조각)에 뒷받침되는지 판정하고, 추측이나 근거 없는 적합성 판단은 unsupportedReasons에 넣어라. 접근 전략과 다음 행동의 사람·회사·시장·고객 약속·확정 일정에 관한 사실 주장을 해당 basis와 인용된 evidence의 title/snippet/url, 명함, context, offer 원문에 대조하라. 전체 evidence가 있어도 각 주장은 자신이 인용한 근거로만 판정. 번호가 존재하는 것만으로 뒷받침된다고 판정하지 말 것. 고객의 미확인 약속·확정 일정은 nextAction에서 특히 unsupportedAction으로 표시할 것. 제안·질문·우리 내부의 향후 계획/목표 기한은 사실 주장이 아니다. JSON 객체만 출력: {"unsupportedReasons":[이유의 i],"unsupportedApproach":[접근 전략의 field],"unsupportedAction":[다음 행동의 field]}.',
+      card, context, offer, evidence, claims, approach: approachClaims, nextAction: actionClaims }));
+    if (!Array.isArray(verdict.unsupportedReasons) || !Array.isArray(verdict.unsupportedApproach) || !Array.isArray(verdict.unsupportedAction)) throw new Error('전략 근거 검증 응답을 읽지 못했다');
+    const badReasons = new Set(verdict.unsupportedReasons.filter((i): i is number => typeof i === 'number' && Number.isInteger(i) && i >= 0 && i < reasons.length));
+    const badApproach = verdict.unsupportedApproach.filter(field => approachClaims.some(claim => claim.field === field));
+    const badAction = verdict.unsupportedAction.filter(field => actionClaims.some(claim => claim.field === field));
+    if (verdict.unsupportedReasons.some(i => !badReasons.has(i as number)) || verdict.unsupportedApproach.length !== badApproach.length || verdict.unsupportedAction.length !== badAction.length) throw new Error('전략 근거 검증 응답을 읽지 못했다');
+    reasons = reasons.filter((_, i) => !badReasons.has(i));
+    if (!invalidNumber && !invalidClaims && (!hasOffer || (reasons.length >= 3 && new Set(reasons.map(reason => reason.basis)).size >= 3)) && badReasons.size === 0 && badApproach.length === 0 && badAction.length === 0) break;
+    // Fit-only shortfalls keep the old two tries (the answer is used with fewer reasons); only rejected approach/action
+    // claims get the third try.
+    if (attempt >= 1 && !(badApproach.length || badAction.length || invalidClaims)) break;
+    if (attempt === LAST && (badApproach.length || badAction.length || invalidClaims)) throw new Error(`근거 없는 접근 전략/다음 행동: ${[...badApproach, ...badAction].join(', ') || '근거 누락'}`);
+    // Name the rejected fields: a site snippet («we build automations») invites a «problem» the page never states
+    // (10-01 dry run, card-followup 0.2.4: strategy failed twice on who/problem once research found the company site).
+    const rejected = [...badApproach, ...badAction];
+    feedback = ' 이전 답에서 존재하지 않는 S# 또는 근거 내용과 불일치하는 이유·접근 전략·다음 행동을 제외하고, 근거 세 개와 주장별 근거를 다시 작성하라. 고객 약속·확정 일정은 확인된 근거가 없으면 쓰지 말고 내부 제안·목표 기한만 적어라.'
+      + (rejected.length ? ` 특히 ${rejected.join(', ')} 는 근거와 맞지 않았다 — 그 필드는 출처가 «직접 말한» 사실만 S# 로 인용하고, 출처가 말하지 않은 회사의 문제·결정권은 «만남 맥락(context)에서 확인할 질문» 꼴로 바꾸거나 basis 를 assumption 으로 적어 추정임을 밝혀라.` : '');
+  }
+  const fitData = object(answer.fit);
+  const score = typeof fitData.score === 'number' && Number.isFinite(fitData.score) && fitData.score >= 0 && fitData.score <= 100 ? fitData.score : null;
+  const label = fitData.label;
+  const grounded = reasons.length >= 3 && new Set(reasons.map(reason => reason.basis)).size >= 3;
+  const fit: Fit = hasOffer
+    ? { score: grounded ? score : null, label: grounded && score !== null && (label === 'high' || label === 'medium' || label === 'low') ? label : 'unknown', reasons }
+    : { score: null, label: 'unknown', reasons: [{ text: 'offer 입력이 없어 맞음을 판정하지 않았다', basis: 'offer' }] };
+  const approachData = object(answer.approach), actionData = object(answer.nextAction);
+  const approach: Approach = {
+    who: text(approachData.who), problem: text(approachData.problem), proposal: text(approachData.proposal),
+    channel: text(approachData.channel), timing: text(approachData.timing),
+  };
+  const nextAction: NextAction = { what: text(actionData.what), due: text(actionData.due) };
+  return { fit, approach, nextAction };
+}
+
+export function crmRow(card: Data, fit: Fit, approach: Approach, nextAction: NextAction, context: string, at: Date | string): CrmRow {
+  return {
+    name: text(card.name), company: text(card.company), title: text(card.title), email: text(card.email),
+    interest: approach.problem, met_context: context, fit_score: fit.score === null ? '' : String(fit.score),
+    fit_label: fit.label, next_action: nextAction.what, due: nextAction.due,
+    updated_at: at instanceof Date ? at.toISOString() : at,
+  };
+}
+
+function parseCsv(content: string): string[][] {
+  const rows: string[][] = [];
+  let row: string[] = [], field = '', quoted = false;
+  for (let i = 0; i < content.length; i++) {
+    const char = content[i]!;
+    if (quoted) {
+      if (char === '"' && content[i + 1] === '"') { field += '"'; i++; }
+      else if (char === '"') quoted = false;
+      else field += char;
+    } else if (char === '"') quoted = true;
+    else if (char === ',') { row.push(field); field = ''; }
+    else if (char === '\n' || char === '\r') {
+      if (char === '\r' && content[i + 1] === '\n') i++;
+      row.push(field); rows.push(row); row = []; field = '';
+    } else field += char;
+  }
+  if (quoted) throw new Error('CRM CSV 따옴표가 닫히지 않음');
+  if (field || row.length) { row.push(field); rows.push(row); }
+  return rows;
+}
+
+const quote = (value: string) => /[",\r\n]/.test(value) ? `"${value.replaceAll('"', '""')}"` : value;
+
+export function upsertCrm(path: string, row: CrmRow): void {
+  const prior = existsSync(path) ? parseCsv(readFileSync(path, 'utf8')) : [];
+  if (prior.length && (prior[0]!.length !== columns.length || columns.some((col, i) => prior[0]![i] !== col))) throw new Error('CRM CSV 헤더 불일치');
+  const records = prior.slice(1).map(values => Object.fromEntries(columns.map((column, i) => [column, values[i] ?? ''])) as CrmRow);
+  const same = (left: CrmRow, right: CrmRow) => right.email
+    ? !!left.email && left.email.toLowerCase() === right.email.toLowerCase()
+    : !left.email && left.name === right.name && left.company === right.company;
+  const index = records.findIndex(existing => same(existing, row));
+  if (index >= 0) records[index] = row;
+  else records.push(row);
+  records.sort((a, b) => (b.fit_score === '' ? -1 : Number(b.fit_score)) - (a.fit_score === '' ? -1 : Number(a.fit_score)));
+  mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
+  writeFileSync(path, [columns.join(','), ...records.map(record => columns.map(column => quote(record[column])).join(','))].join('\n') + '\n', { mode: 0o600 });
+}

package/plugins/card-followup/plugin.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://antigravity.google/schemas/v1/plugin.json",
   "name": "card-followup",
-  "version": "0.1.0",
+  "version": "0.2.9",
   "description": "Business card photo to researched follow-up and LinkedIn drafts. Drafts are never sent.",
   "extensions": {
     "ai.elanous": {

package/plugins/doc-draft/README.md

@@ -0,0 +1,13 @@
+# doc-draft
+
+Drafts one document from a request: an executive one-pager, a promo/event post, or a memo. **Drafts only; never published.** It does not post, send, or pay for anything.
+
+Run from the repository without installing the plugin (install it for COO to discover `doc-draft`):
+
+```sh
+elanous graph run plugins/doc-draft/graphs/doc-draft.yaml --input '{"kind":"exec-onepager","topic":"Summarize the event readiness check for leadership"}' --json
+```
+
+Inputs: `kind` (required: `exec-onepager`, `promo-post`, `memo`), `topic` (required one-line request), `context` (optional previous seat results or source summary), `audience` (optional), `language` (optional, default `ko`), and `outDir` (optional, default beside the graph run state file). The `examples/brief-sample.json` keys are read by the COO planner; its values are illustrative only.
+
+The `draft` step calls `elanous ask --bare --json` from a fresh empty temporary folder, then `check` checks the draft and asks for a review against the requested items and source context. An older CLI that rejects `--bare` falls back to `ask --json`. `DOC_DRAFT_ELANOUS_BIN` substitutes the CLI executable in tests. Each step emits final-line JSON; failures route to `failed`. Only after `check` succeeds does `report` write `outDir/draft.md` (one Markdown title line plus body), with final-line JSON `{ "outcome": "ok", "file": "…/draft.md", "words": 123 }`. An executive one-pager includes 요약, 핵심 숫자, 결정 요청, and 다음 단계; missing figures are marked as unprovided rather than invented. If `draft.md` already exists in `outDir`, `report` fails without replacing it; choose a fresh output directory for a new run. No publication or delivery happens.

package/plugins/doc-draft/examples/brief-sample.json

@@ -0,0 +1,8 @@
+{
+  "kind": "exec-onepager",
+  "topic": "Example product launch readiness",
+  "context": "Example research found three customer questions still unanswered.",
+  "audience": "Example leadership team",
+  "language": "ko",
+  "outDir": "/tmp/example-doc-draft"
+}

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

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

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

@@ -0,0 +1,9 @@
+draft:
+  command: 'bun "$ELANOUS_GRAPH_DIR/run-step.ts" draft'
+  timeout_ms: 120000
+check:
+  command: 'bun "$ELANOUS_GRAPH_DIR/run-step.ts" check'
+  timeout_ms: 30000
+report:
+  command: 'bun "$ELANOUS_GRAPH_DIR/run-step.ts" report'
+  timeout_ms: 30000