elanous 0.2.21 → 0.2.23

package/src/intake-plane/digest.ts

@@ -9,7 +9,8 @@ import { intakeOutboxDir, kstDay } from './route.js';
 
 export type DigestLensVerdict = '대체 후보' | '보강' | '경쟁 대조';
 export interface DigestEntry { id: string; sources: string[]; url?: string; note?: string; noteName?: string; oneLiner?: string; axis: string; impact?: { verdict: DigestLensVerdict; why: string; target: string } }
-export interface IntakeDigest { day: string; seat?: string; absorbed: DigestEntry[]; goals: { fact: string; url?: string }[]; news?: { title: string; url: string; summary: string[]; implication: string[] }[]; shadowSuggestions?: { fact: string; url?: string; verdict: string }[]; review?: { fact: string; note?: string }[]; grounding: number; release: number; manual: number; savedSilence?: { days: number; lastNewAt: string } }
+export interface DigestLedgerEntry { id: string; title: string; url: string; verdict: DigestLensVerdict | '참고' | '판정 대기' }
+export interface IntakeDigest { day: string; seat?: string; absorbed: DigestEntry[]; goals: { fact: string; url?: string }[]; news?: { title: string; url: string; summary: string[]; implication: string[] }[]; xTrends?: DigestLedgerEntry[]; githubNew?: DigestLedgerEntry[]; shadowSuggestions?: { fact: string; url?: string; verdict: string }[]; review?: { fact: string; note?: string }[]; grounding: number; release: number; manual: number; savedSilence?: { days: number; lastNewAt: string } }
 
 const AXIS_LABEL: Record<string, string> = {
   video_automation: '영상 자동화', agent_basics: '에이전트 기본', agent_applied: '에이전트 응용', unrelated: '그 밖',
@@ -69,29 +70,31 @@ export function buildIntakeDigest(root: string, day: string, readFile: (p: strin
   const briefedEarlier = new Set(selectedSeat
     ? readJsonl(seatBriefFile(root, selectedSeat)).filter((r) => typeof r.id === 'string' && r.day !== day).map((r) => r.id as string)
     : []);
-  const items = [...loadIntakeLedger(root).items.values()]
+  const ledgerItems = [...loadIntakeLedger(root).items.values()];
+  const items = ledgerItems
     .filter((i) => (selectedSeat === undefined || (i.seat === selectedSeat && !briefedEarlier.has(i.id)))
       && (selectedSeat ? i.status !== 'discarded' : (i.status === 'absorbed' || i.status === 'routed') && i.outputs.some((o) => o.kind === 'note'))
       && kstDay(i.lastSeenAt) === day);
   const out = intakeOutboxDir(root);
-  const relevant = new Map<string, NonNullable<DigestEntry['impact']>>();
-  // The lens (src/intake-plane/lens.ts) writes its verdicts to outbox/lens/<day>.jsonl; route folders carry none.
-  for (const folder of ['lens'] as const) {
-    for (const row of readJsonl(join(out, folder, `${day}.jsonl`))) {
-      if (typeof row.id !== 'string' || relevant.has(row.id)) continue;
-      const verdict = row.lensVerdict;
-      if (verdict !== '대체 후보' && verdict !== '보강' && verdict !== '경쟁 대조') continue;
-      const why = typeof row.why === 'string' ? row.why.trim() : '';
-      const target = typeof row.target === 'string' ? row.target.trim() : '';
-      // A check's fact/current or repo path is evidence, not a lens judgement or a reason for us.
-      if (!why || !target || pathOnly(why)) continue;
-      relevant.set(row.id, { verdict, why, target });
-    }
+  const allLensRows = readJsonl(join(out, 'lens', `${day}.jsonl`));
+  const ledgerDecisions = new Map<string, { verdict: Exclude<DigestLedgerEntry['verdict'], '판정 대기'>; why: string; target: string }>();
+  // The first valid lens row owns an ID's verdict for both absorbed notes and same-day ledger sections.
+  for (const row of allLensRows) {
+    if (typeof row.id !== 'string' || ledgerDecisions.has(row.id)) continue;
+    const verdict = row.lensVerdict;
+    if (verdict !== '대체 후보' && verdict !== '보강' && verdict !== '경쟁 대조' && verdict !== '참고') continue;
+    const why = typeof row.why === 'string' ? row.why.trim() : '';
+    const target = typeof row.target === 'string' ? row.target.trim() : '';
+    // A check's fact/current or repo path is evidence, not a lens judgement or a reason for us.
+    if (!why || !target || pathOnly(why)) continue;
+    ledgerDecisions.set(row.id, { verdict, why, target });
   }
   const absorbed = items.map((i: IntakeItem): DigestEntry => {
     const note = [...i.outputs].reverse().find((o) => o.kind === 'note')?.ref;
     const md = note ? readFile(note) : undefined;
-    const impact = relevant.get(i.id);
+    const decision = ledgerDecisions.get(i.id);
+    const impact = decision && decision.verdict !== '참고'
+      ? { verdict: decision.verdict, why: decision.why, target: decision.target } : undefined;
     return {
       id: i.id, sources: i.sources, ...(i.url ? { url: i.url } : {}),
       ...(note ? { note, noteName: basename(note, '.md') } : {}),
@@ -101,11 +104,19 @@ export function buildIntakeDigest(root: string, day: string, readFile: (p: strin
     };
   });
   const goals = selectedSeat ? [] : readJsonl(join(out, 'goals', `${day}.jsonl`)).map((g) => ({ fact: String(g.fact ?? ''), ...(g.url ? { url: String(g.url) } : {}) }));
-  const lensRows = selectedSeat ? [] : readJsonl(join(out, 'lens', `${day}.jsonl`));
+  const lensRows = selectedSeat ? [] : allLensRows;
   const news = lensRows.flatMap((row) =>
     typeof row.title === 'string' && typeof row.url === 'string' && Array.isArray(row.summary) && Array.isArray(row.implication)
       ? [{ title: row.title, url: row.url, summary: row.summary.filter((s): s is string => typeof s === 'string'), implication: row.implication.filter((s): s is string => typeof s === 'string') }]
       : []);
+  const ledgerEntry = (item: IntakeItem): DigestLedgerEntry => ({
+    id: item.id, title: item.title?.trim() || item.url!, url: item.url!,
+    verdict: ledgerDecisions.get(item.id)?.verdict ?? '판정 대기',
+  });
+  const sameDayLedger = selectedSeat ? [] : ledgerItems
+    .filter((item) => item.status !== 'discarded' && item.url && kstDay(item.lastSeenAt) === day);
+  const xTrends = sameDayLedger.filter((item) => item.sources.includes('x')).map(ledgerEntry);
+  const githubNew = sameDayLedger.filter((item) => item.sources.includes('github')).map(ledgerEntry);
   const shadowSuggestions = lensRows.flatMap((row) =>
     Array.isArray(row.suggestions) ? row.suggestions.flatMap((raw: unknown) => {
       if (!raw || typeof raw !== 'object' || Array.isArray(raw)) return [];
@@ -118,7 +129,7 @@ export function buildIntakeDigest(root: string, day: string, readFile: (p: strin
   const lastNewAt = selectedSeat ? undefined : readSavedCursorAt(root);
   const silentMs = lastNewAt ? now.getTime() - Date.parse(lastNewAt) : NaN;
   return {
-    day, ...(selectedSeat ? { seat: selectedSeat } : {}), absorbed, goals, ...(news.length ? { news } : {}), ...(shadowSuggestions.length ? { shadowSuggestions } : {}), review, grounding,
+    day, ...(selectedSeat ? { seat: selectedSeat } : {}), absorbed, goals, ...(news.length ? { news } : {}), ...(xTrends.length ? { xTrends } : {}), ...(githubNew.length ? { githubNew } : {}), ...(shadowSuggestions.length ? { shadowSuggestions } : {}), review, grounding,
     release: selectedSeat ? 0 : readJsonl(join(out, 'release', `${day}.jsonl`)).length,
     manual: selectedSeat ? 0 : readJsonl(join(out, 'manual', `${day}.jsonl`)).length,
     ...(!selectedSeat && lastNewAt && silentMs > SAVED_SILENCE_MS ? { savedSilence: { days: Math.floor(silentMs / 86_400_000), lastNewAt } } : {}),
@@ -142,8 +153,10 @@ function digestReferenceLine(entries: DigestEntry[]): string {
 export function renderDigestMarkdown(d: IntakeDigest): string {
   const L: string[] = [`## 📰 오늘의 흡수 요약 (${d.absorbed.length})`, ''];
   if (d.savedSilence) L.push(`> ⚠️ 텔레그램 «저장된 메시지»에서 새 글을 ${d.savedSilence.days}일째 못 받았다(마지막 새 글 수집 ${kstDay(d.savedSilence.lastNewAt)}) — 저장했는데 안 들어왔다면 저장한 곳(본인 «저장된 메시지»인지)을 확인한다.`, '');
-  if (!d.absorbed.length) L.push('오늘 흡수한 것이 없다.', '');
-  if (!d.absorbed.length && !d.news?.length) return L.join('\n');
+  if (!d.absorbed.length && !d.news?.length && !d.xTrends?.length && !d.githubNew?.length) {
+    L.push('오늘 흡수한 것이 없다.', '');
+    return L.join('\n');
+  }
   const byAxis = new Map<string, DigestEntry[]>();
   for (const e of d.absorbed) (byAxis.get(e.axis) ?? byAxis.set(e.axis, []).get(e.axis)!).push(e);
   for (const [axis, rows] of byAxis) {
@@ -160,6 +173,12 @@ export function renderDigestMarkdown(d: IntakeDigest): string {
     }
     L.push('');
   }
+  for (const [heading, entries] of [['X 트렌드', d.xTrends], ['GitHub 신규', d.githubNew]] as const) {
+    if (!entries?.length) continue;
+    L.push(`### ${heading} (${entries.length})`, '');
+    for (const entry of entries) L.push(`- [${entry.title}](${entry.url}) — ${entry.verdict}`);
+    L.push('');
+  }
   if (d.goals.length) {
     L.push(`### 🔴 엘라누스에 없는 것 — 골 후보 (${d.goals.length})`, '');
     for (const g of d.goals.slice(0, 10)) L.push(`- ${g.fact}${g.url ? ` · [원본](${g.url})` : ''}`);
@@ -189,6 +208,12 @@ export function renderDigestTelegram(d: IntakeDigest, _opts: { vaultRoot?: strin
     L.push(article.url);
   }
   if (d.shadowSuggestions?.length) L.push(`뉴스 칸 제안 ${d.shadowSuggestions.length}건 (그림자·판 미등록): ${d.shadowSuggestions.slice(0, 3).map((s) => `[${s.verdict}] ${s.fact}${s.url ? ` ${s.url}` : ''}`).join(' · ')}`);
+  for (const [heading, entries] of [['X 트렌드', d.xTrends], ['GitHub 신규', d.githubNew]] as const) {
+    if (!entries?.length) continue;
+    L.push('', `${heading} (${entries.length})`);
+    for (const entry of entries.slice(0, 5)) L.push(`- [${entry.verdict}] ${entry.title} — ${entry.url}`);
+    if (entries.length > 5) L.push(`외 ${entries.length - 5}건 · 원장 \`elanous intake items\``);
+  }
   // At most three items are shown, each as its own S·C·A·note block so context and source stay paired.
   // S must be the note's own summary: items without one still count as touching but are not shown (ACP must-fix).
   const shownItems = touching.filter((e) => e.oneLiner?.trim()).slice(0, 3);

package/src/intake-plane/lens.ts

@@ -1,10 +1,11 @@
-// 흡수 렌즈 — outbox 항목마다 «우리에게 무엇인가»를 판정해 outbox/lens/<day>.jsonl 에만 남긴다.
-// 원 갈래(goals·manual·review·release)는 읽기만 한다. LLM 은 judge 한 번(id 당).
+// 흡수 렌즈 — E1 outbox 와 같은 날 공개 GitHub·X 원장 항목을 판정해 outbox/lens/<day>.jsonl 에만 남긴다.
+// 원 갈래(goals·manual·review·release)와 원장은 읽기만 한다. LLM 은 judge 한 번(id 당).
 import { appendFileSync, existsSync, mkdirSync, readFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { debug } from '../debug/log.js';
 import { judge } from '../llm/judge-layer.js';
-import { intakeOutboxDir } from './route.js';
+import { loadIntakeLedger } from './items.js';
+import { intakeOutboxDir, kstDay } from './route.js';
 
 export const LENS_VERDICTS = ['대체 후보', '보강', '경쟁 대조', '참고'] as const;
 export type LensVerdict = (typeof LENS_VERDICTS)[number];
@@ -98,6 +99,26 @@ function groupOutbox(root: string, day: string): GroupedItem[] {
   return order.map((id) => groups.get(id)!);
 }
 
+function ledgerLensItems(root: string, day: string, existing: ReadonlySet<string>): GroupedItem[] {
+  const items: GroupedItem[] = [];
+  const seen = new Set(existing);
+  const ledger = [...loadIntakeLedger(root).items.values()];
+  for (const source of ['github', 'x'] as const) {
+    for (const item of ledger) {
+      if (!item.id || seen.has(item.id) || item.status === 'discarded' || item.privacy !== 'public'
+        || !item.url || kstDay(item.lastSeenAt) !== day || !item.sources?.includes(source)) continue;
+      const title = item.title?.trim();
+      const text = item.text?.trim();
+      const facts = [title, text].filter((value): value is string => Boolean(value)).slice(0, LENS_FACT_CAP)
+        .map((fact) => ({ fact, current: '' }));
+      if (!facts.length) continue;
+      seen.add(item.id);
+      items.push({ id: item.id, facts, url: item.url });
+    }
+  }
+  return items;
+}
+
 function judgedIds(file: string): Set<string> {
   return new Set(readJsonl(file).flatMap((row) => typeof row.id === 'string' && row.id ? [row.id] : []));
 }
@@ -130,7 +151,7 @@ async function defaultJudge(item: GroupedItem): Promise<unknown> {
   return decision.value;
 }
 
-/** 그날 outbox 를 id 로 묶어 아직 없는 판정만 남긴다. 원 갈래 파일은 쓰지 않는다. */
+/** 그날 E1 outbox 뒤에 공개 GitHub·X 원장을 붙여 아직 없는 판정만 남긴다. 원천 파일은 쓰지 않는다. */
 export async function annotateIntakeLens(
   root: string,
   day: string,
@@ -142,13 +163,20 @@ export async function annotateIntakeLens(
     log('skipped-test', {});
     return empty;
   }
-  const items = groupOutbox(root, day);
+  const outbox = groupOutbox(root, day);
+  const ledger = ledgerLensItems(root, day, new Set(outbox.map((item) => item.id)));
+  const items = [...outbox, ...ledger];
   const file = join(intakeOutboxDir(root), 'lens', `${day}.jsonl`);
   const done = judgedIds(file);
   const pending = items.filter((item) => !done.has(item.id));
-  const capped = pending.length > LENS_DAILY_CAP;
-  const batch = pending.slice(0, LENS_DAILY_CAP);
-  if (capped) log('capped', { day, total: pending.length, judged: batch.length });
+  const remaining = Math.max(0, LENS_DAILY_CAP - done.size);
+  const capped = pending.length > remaining;
+  const batch = pending.slice(0, remaining);
+  if (capped) {
+    const skippedIds = pending.slice(remaining).map((item) => item.id);
+    log('capped', { day, total: pending.length, judged: batch.length, skippedIds,
+      ...(skippedIds.length ? { marker: `외 ${skippedIds.length}건 · 원장 \`elanous intake items\`` } : {}) });
+  }
   const judgeOne = deps.judge ?? ((input: LensJudgeInput) => defaultJudge(input));
   const now = deps.now ?? (() => new Date().toISOString());
   let judged = 0;

package/src/intelligence-map/model-alias.ts

@@ -35,6 +35,12 @@ const MODEL_ALIASES: Readonly<Record<string, string>> = {
   'opus-5':          'claude-opus-5',
   'opus-4-8':        'claude-opus-4-8',
   'opus-4-7':        'claude-opus-4-7',    // 하위호환
+  // ⭐ 2026-10-10 (MK) — 5.5 세대는 판을 붙여서만 부른다(맨몸 `sonnet`·`haiku` 는 옮기지 않았다 — 별개 결정).
+  //   공식 API id 는 하이픈(`claude-sonnet-5-5`)인데 OpenRouter·사람은 점(`claude-sonnet-5.5`)으로 쓴다 — 둘 다 받는다.
+  'sonnet-5-5':        'claude-sonnet-5-5',
+  'haiku-5-5':         'claude-haiku-5-5',
+  'claude-sonnet-5.5': 'claude-sonnet-5-5',
+  'claude-haiku-5.5':  'claude-haiku-5-5',
   // Google Gemini family
   'flash':           'gemini-3.8-flash',   // ⭐ 2026-09-25 최신 flash(models.list 실측)
   'flash-3-7':       'gemini-3.7-flash',

package/src/intelligence-map/model-catalog.ts

@@ -794,6 +794,47 @@ export const BUILTIN_CATALOG: ModelCatalog = {
       mlxRepo: 'lmstudio-community/NVIDIA-Nemotron-3-Nano-30B-A3B-MLX-8bit',
       notes: 'NVIDIA Open Model License · 30B/3B MoE · 1M ctx · text+vision+audio+video · Q4 ~28GB / MLX-8bit ~36GB · M5 Max OK',
     },
+    // ⭐ 2026-10-10 (MK · MODEL-ROUTING-MATRIX) — `--child-llm-model` 이 이 둘을 «알 수 없음»으로 거부했다
+    //    (UX 17:36 실측 · 해석은 이 표 ⊕ src/anthropic/models.ts 만 본다). 값은 Anthropic 공식 1차
+    //    (platform.claude.com/내부 문서 `overview` · 2026-10-10T08:38Z 직접 확인)
+    //    ⊕ OpenRouter /api/v1/models 실측(05:10Z) 이 같다. 별칭(`sonnet`·`haiku`)은 옮기지 않는다 — 별개 결정.
+    // ⛔ 표의 «맨 끝»에 둔 것은 의도다 — `recommendModel` 은 같은 가격이면 표 순서로 고른다(안정 정렬).
+    //    haiku-5-5($0.10/$0.50)는 gpt-6-luna 와 값이 같아, 앞에 두면 'cheap' 추천이 조용히 haiku 로 바뀐다
+    //    (게다가 haiku 는 >100k 프롬프트가 5배라 이 칸 하나로는 싸다고 말할 수 없다). 추천 변경은 별개 결정.
+    {
+      // 📏 공식: Released 2026-09-28 · 1M ctx · 출력 128K · $2/$10 · 캐시 읽기 $0.10(입력의 5%) · Adaptive · 기본 effort high.
+      id: 'claude-sonnet-5-5',
+      provider: 'anthropic',
+      family: 'claude',
+      contextWindow: 1_000_000,
+      inputPerMtok: 2,
+      outputPerMtok: 10,
+      local: false,
+      tags: ['reasoning', 'coding', 'balanced', 'long-context'],
+      bestFor: ['daily-coding', 'multi-turn-chat', 'summarization'],
+      envKey: 'ANTHROPIC_API_KEY',
+      reservedOutputTokens: 8_000,
+      reasoningEffortCeiling: 'high',  // adaptive thinking (공식 «Adaptive»)
+      releasedAt: '2026-09-28',
+    },
+    {
+      // 📏 공식: Released 2026-10-07 · 1M ctx · 출력 128K · Adaptive · 기본 effort medium.
+      // ⚠️ 가격이 프롬프트 길이 구간으로 갈린다 — ≤100k 토큰 $0.10/$0.50 · >100k $0.50/$2.50(요청 전체).
+      //    칸이 하나라 «≤100k» 를 싣는다.
+      id: 'claude-haiku-5-5',
+      provider: 'anthropic',
+      family: 'claude',
+      contextWindow: 1_000_000,
+      inputPerMtok: 0.1,
+      outputPerMtok: 0.5,
+      local: false,
+      tags: ['classification', 'summarization', 'cheap', 'fast', 'long-context'],
+      bestFor: ['classification', 'routing', 'bulk-summarization', 'subagent-tasks'],
+      envKey: 'ANTHROPIC_API_KEY',
+      reservedOutputTokens: 8_000,
+      reasoningEffortCeiling: 'high',  // 공식: adaptive thinking ⊕ effort 파라미터 지원(haiku-4-5 의 'low' 와 다르다)
+      releasedAt: '2026-10-07',
+    },
   ],
 };
 

package/src/knowledge/conclusion-compress.ts

@@ -0,0 +1,93 @@
+import { createHash, randomUUID } from 'node:crypto';
+import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+import { releaseLedgerRoot } from '../instance/resolve.js';
+import { listChecklist, setItem } from '../release-loop/checklist.js';
+import { withFileLockSync } from '../storage/file-lock.js';
+
+export type ConclusionKind = 'evidence' | 'decision' | 'lesson';
+export type ConclusionSource = 'goal' | 'handoff' | 'run-log' | 'channel' | 'pr-discussion';
+export interface ConclusionRecord {
+  source: ConclusionSource;
+  cell: string;
+  kind: ConclusionKind;
+  conclusion: string;
+  /** Original URL, or a relative path to the original for non-channel sources. */
+  ref: string;
+  body: string;
+  /** The original post's UTC timestamp; required when compressing a channel day. */
+  createdAt?: string;
+  /** Terminal status is required before a run can be archived. */
+  status?: string;
+}
+export interface ConclusionBatch {
+  version: string;
+  day: string;
+  records: ConclusionRecord[];
+}
+export interface ConclusionReceipt {
+  archive: string;
+  lines: string[];
+  originalBytes: number;
+  conclusionBytes: number;
+}
+
+const kinds = new Set<ConclusionKind>(['evidence', 'decision', 'lesson']);
+const sources = new Set<ConclusionSource>(['goal', 'handoff', 'run-log', 'channel', 'pr-discussion']);
+const closed = new Set(['done', 'failed', 'cancelled', 'superseded', 'completed', 'abandoned']);
+const validDay = (day: string) => /^\d{4}-\d{2}-\d{2}$/.test(day) && new Date(`${day}T00:00:00Z`).toISOString().slice(0, 10) === day;
+
+/** Archive a complete input batch; publish only source-linked, explicitly supplied conclusions to the checklist ledger. */
+export function compressConclusions(batch: ConclusionBatch, root = releaseLedgerRoot()): ConclusionReceipt {
+  if (!batch || !Array.isArray(batch.records) || !batch.records.length || !validDay(batch.day)) throw new Error('invalid day or empty records');
+  if (!/^\d+\.\d+\.\d+(?:-(?:rc|alpha|beta)\.\d+)?$/.test(batch.version)) throw new Error('invalid checklist version');
+  if (resolve(root) !== resolve(releaseLedgerRoot())) throw new Error('archive and checklist must share a ledger root');
+  const checklist = listChecklist(batch.version);
+  const digest = createHash('sha256').update(JSON.stringify(batch)).digest('hex');
+  const archiveRef = `knowledge-compress/archive/${digest}.json`;
+  const byCell = new Map<string, string[]>();
+  for (const [index, record] of batch.records.entries()) {
+    if (!record || !sources.has(record.source) || !kinds.has(record.kind) ||
+      !checklist.items.some(item => item.id === record.cell) || !record.body?.trim() ||
+      !record.conclusion?.trim() || /[\r\n]/.test(record.conclusion) || !record.ref?.trim()) {
+      throw new Error('unverified source, conclusion or checklist cell');
+    }
+    if (record.source === 'channel') {
+      if (!/^https:\/\/github\.com\/[^\s]+#issuecomment-\d+$/.test(record.ref) ||
+        !record.createdAt || !Number.isFinite(Date.parse(record.createdAt)) ||
+        new Date(record.createdAt).toISOString().slice(0, 10) !== batch.day) throw new Error('channel comment must link to the selected UTC day');
+    }
+    if (record.source === 'run-log' && !closed.has(record.status ?? '')) throw new Error('run is not finished');
+    const conclusion = record.conclusion.trim().replace(/\s+/g, ' ');
+    if (conclusion.length > 160 || !conclusion) throw new Error('conclusion exceeds one line');
+    const ref = record.ref.trim();
+    if (/\s|[\r\n]/.test(ref) || (record.source !== 'channel' && !/^(https:\/\/|[^/][^\s]*$)/.test(ref))) throw new Error('invalid source pointer');
+    const line = `${record.kind}: ${conclusion} (${record.source === 'channel' ? ref : `${archiveRef}#record-${index + 1}`})`;
+    byCell.set(record.cell, [...(byCell.get(record.cell) ?? []), line]);
+  }
+  const lines = [...byCell].flatMap(([cell, entries]) => [...new Set(entries)].map(line => `${cell} · ${line}`));
+  const originalBytes = Buffer.byteLength(JSON.stringify(batch.records));
+  const conclusionBytes = Buffer.byteLength(lines.join('\n'));
+  if (conclusionBytes * 10 > originalBytes) throw new Error(`conclusions exceed 1/10 of original (${conclusionBytes}/${originalBytes} bytes)`);
+
+  const dir = join(root, 'knowledge-compress');
+  const archive = join(root, archiveRef);
+  const lock = join(dir, 'conclusions.lock');
+  mkdirSync(dirname(archive), { recursive: true });
+  return withFileLockSync(lock, () => {
+    if (existsSync(archive)) {
+      if (readFileSync(archive, 'utf8') !== JSON.stringify(batch)) throw new Error('archive digest collision');
+    } else {
+      const temp = `${archive}.${randomUUID()}.tmp`;
+      writeFileSync(temp, JSON.stringify(batch), { flag: 'wx', mode: 0o600 });
+      renameSync(temp, archive);
+    }
+    for (const [cell, entries] of byCell) {
+      const existing = listChecklist(batch.version).items.find(item => item.id === cell);
+      if (!existing) throw new Error(`checklist cell disappeared: ${cell}`);
+      const additions = [...new Set(entries)].filter(line => !existing.evidence?.split('\n').includes(line));
+      if (additions.length) setItem(batch.version, cell, { evidence: [existing.evidence, ...additions].filter(Boolean).join('\n') }, 'knowledge-compress');
+    }
+    return { archive: resolve(archive), lines, originalBytes, conclusionBytes };
+  });
+}

package/src/knowledge/kgs/pack.ts

@@ -50,14 +50,17 @@ export interface PackId {
 }
 
 const SLUG_RE = /^[a-z0-9][a-z0-9-]{1,62}[a-z0-9]$/;
-const VERSION_RE = /^\d+\.\d+\.\d+(?:-[a-z0-9-]+)?$/;
+const VERSION_RE = /^(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)(?:-[a-z0-9-]+(?:\.[a-z0-9-]+)*)?$/;
 
 export function isPackSlug(v: unknown): v is string {
   return typeof v === 'string' && SLUG_RE.test(v);
 }
 
 export function isPackVersion(v: unknown): v is string {
-  return typeof v === 'string' && VERSION_RE.test(v);
+  if (typeof v !== 'string' || !VERSION_RE.test(v)) return false;
+  const separator = v.indexOf('-');
+  const prerelease = separator < 0 ? undefined : v.slice(separator + 1);
+  return prerelease === undefined || prerelease.split('.').every(id => !/^\d+$/.test(id) || id === '0' || !id.startsWith('0'));
 }
 
 export function packIdString(id: PackId): string {

package/src/knowledge/kgs/sqlite-store.ts

@@ -209,6 +209,21 @@ export class KgsSqliteStore {
     );
   }
 
+  /** Remove only the selected version; standalone pack cards live inside its payload. */
+  deletePack(slug: string, version: string): boolean {
+    return this.db.run('DELETE FROM kgs_pack WHERE slug = ? AND version = ?', [slug, version]).changes > 0;
+  }
+
+  /** Switch versions as one SQLite transaction so failed upgrades retain the old index. */
+  replacePack(previous: { slug: string; version: string }, next: Pack): void {
+    this.db.transaction(() => {
+      if (!this.readPack(previous.slug, previous.version)) throw new Error('pack not installed');
+      if (this.readPack(next.metadata.id.slug, next.metadata.id.version)) throw new Error('pack version already installed');
+      this.writePack(next);
+      if (!this.deletePack(previous.slug, previous.version)) throw new Error('pack not removed');
+    })();
+  }
+
   readPack(slug: string, version: string): Pack | null {
     const row = this.db
       .query(`SELECT payload FROM kgs_pack WHERE slug = ? AND version = ?`)

package/src/knowledge/know-find.ts

@@ -3,6 +3,7 @@ import { LessonLedger, type LessonRow } from '../lessons/lesson-ledger.js';
 import { DecisionLedger, type DecisionEntry, type SeatDecisionRecord } from '../decisions/decision-ledger.js';
 import { devVersion, listChecklist, type Checklist } from '../release-loop/checklist.js';
 import { debug } from '../debug/log.js';
+import { queryInstalledPack } from './query.js';
 
 /** Directive row fields this search reads — kept local because `src/directives/directive-index` is excluded from the public export. */
 export interface DirectiveRow { ts: string; text: string; source_file: string; line_no: number }
@@ -14,7 +15,7 @@ function openDirectiveIndex(): { search(q: string): DirectiveRow[]; close(): voi
   return new mod.DirectiveIndex();
 }
 
-export type KnowSource = 'directive' | 'decision' | 'checklist' | 'lesson';
+export type KnowSource = 'directive' | 'decision' | 'checklist' | 'lesson' | 'pack';
 export interface KnowHit {
   source: KnowSource;
   id: string;
@@ -36,6 +37,7 @@ export interface KnowFindDeps {
   lessons: (query: string) => LessonRow[];
   versions: () => string[];
   now: () => Date;
+  pack?: typeof queryInstalledPack;
 }
 
 function versions(): string[] {
@@ -55,6 +57,7 @@ const defaults: KnowFindDeps = {
   lessons: (query) => new LessonLedger().find(query),
   versions,
   now: () => new Date(),
+  pack: queryInstalledPack,
 };
 
 function matches(text: string, words: string[]): boolean {
@@ -62,7 +65,7 @@ function matches(text: string, words: string[]): boolean {
   return words.every((word) => normalized.includes(word));
 }
 
-export function knowFind(query: string, deps: Partial<KnowFindDeps> = {}): KnowResult {
+export function knowFind(query: string, deps: Partial<KnowFindDeps> = {}, packId?: string): KnowResult {
   const read = { ...defaults, ...deps };
   const words = query.trim().toLocaleLowerCase().split(/\s+/).filter(Boolean);
   if (!words.length) throw new Error('know: 질문이 필요합니다');
@@ -106,6 +109,10 @@ export function knowFind(query: string, deps: Partial<KnowFindDeps> = {}): KnowR
     for (const row of read.lessons(query)) rows.push({ source: 'lesson', id: row.id, title: row.incident,
       status: row.status, at: row.updated_at, current: row.occurrence_count > 1, ref: `lesson show ${row.id}` });
   });
+  if (packId) attempt('pack', () => {
+    for (const card of (read.pack ?? queryInstalledPack)(packId, query)) rows.push({ source: 'pack', id: card.id, title: card.title,
+      status: 'installed', at: card.updatedAt, current: true, ref: card.ref });
+  });
   rows.sort((a, b) => Number(b.current) - Number(a.current) || (Date.parse(b.at) || 0) - (Date.parse(a.at) || 0)
     || a.source.localeCompare(b.source) || a.id.localeCompare(b.id));
   debug.log('knowledge.know', 'query', { query, counts: Object.fromEntries((['directive', 'decision', 'checklist', 'lesson'] as const)

package/src/knowledge/query.ts

@@ -10,6 +10,26 @@ import { readFileSync, existsSync, readdirSync, statSync } from 'node:fs';
 import { join, relative, sep } from 'node:path';
 import { parseFrontmatter, type ObsidianVault } from '../auto-research/obsidian-bridge.js';
 import type { KnowledgeKind, KnowledgeNote, KnowledgeQueryInput, KnowledgeQueryResult } from './types.js';
+import { PACK_KINDS, parsePackIdString, packIdString } from './kgs/pack.js';
+import { kgsStoreSingleton, type KgsSqliteStore } from './kgs/sqlite-store.js';
+
+/** Search only cards belonging to a pack present in the local KGS index. No vault fallback. */
+export function listInstalledPacks(store: Pick<KgsSqliteStore, 'listPacksByKind'> = kgsStoreSingleton()): Array<{ id: string; title: string }> {
+  return PACK_KINDS.flatMap(kind => store.listPacksByKind(kind).map(pack => ({ id: packIdString(pack.metadata.id), title: pack.metadata.title })));
+}
+
+export function queryInstalledPack(packId: string, question: string, store: Pick<KgsSqliteStore, 'readPack'> = kgsStoreSingleton()): Array<{ id: string; title: string; body: string; ref: string; updatedAt: string }> {
+  const id = parsePackIdString(packId);
+  if (!id) throw new Error(`invalid pack id: ${packId}`);
+  const pack = store.readPack(id.slug, id.version);
+  if (!pack) throw new Error(`pack not installed: ${packId}`);
+  const words = question.trim().toLocaleLowerCase().split(/\s+/).filter(Boolean);
+  return pack.cards.map(card => ({ card, score: words.filter(word => `${card.title} ${card.body}`.toLocaleLowerCase().includes(word)).length }))
+    .filter(hit => hit.score > 0 || words.length === 0)
+    .sort((a, b) => b.score - a.score || a.card.id.localeCompare(b.card.id))
+    .map(({ card }) => ({ id: card.id, title: card.title, body: card.body,
+      ref: `${packIdString(pack.metadata.id)}#${card.id}`, updatedAt: card.updatedAt }));
+}
 
 const DEFAULT_LIMIT = 20;
 const MAX_LIMIT = 100;

package/src/knowledge/tools/knowledge-query.ts

@@ -2,10 +2,12 @@
 
 import type { LLMToolSpec } from '../../llm.js';
 import { discoverObsidianVault, type ObsidianVault } from '../../auto-research/obsidian-bridge.js';
-import { knowledgeQuery } from '../query.js';
+import { knowledgeQuery, queryInstalledPack } from '../query.js';
 import type { KnowledgeQueryInput, KnowledgeQueryResult } from '../types.js';
 
 export interface KnowledgeQueryToolInput {
+  pack_id?: string;
+  question?: string;
   tags?: string[];
   fulltext?: string;
   kind?: 'all' | 'rca' | 'a3' | 'incident' | 'wiki' | 'repomap' | 'note';
@@ -16,6 +18,8 @@ export interface KnowledgeQueryToolInput {
 
 export interface KnowledgeQueryToolResult {
   output: string;
+  /** Cited cards when pack_id is supplied; absent on the existing vault query path. */
+  pack_hits?: ReturnType<typeof queryInstalledPack>;
   results: KnowledgeQueryResult['results'];
   total: number;
   truncated: boolean;
@@ -24,12 +28,24 @@ export interface KnowledgeQueryToolResult {
 
 export interface KnowledgeQueryDispatchOpts {
   vault?: ObsidianVault;
+  searchPack?: typeof queryInstalledPack;
 }
 
 export async function dispatchKnowledgeQuery(
   input: KnowledgeQueryToolInput,
   opts: KnowledgeQueryDispatchOpts = {},
 ): Promise<KnowledgeQueryToolResult> {
+  if (input.pack_id !== undefined) {
+    try {
+      if (!input.question?.trim()) throw new Error('question required for pack search');
+      const hits = (opts.searchPack ?? queryInstalledPack)(input.pack_id, input.question);
+      return { output: hits.map(hit => `[${hit.ref}] ${hit.title}: ${hit.body}`).join('\n') || 'No matching installed pack cards.',
+        pack_hits: hits, results: [], total: hits.length, truncated: false };
+    } catch (error) {
+      return { output: `KnowledgeQuery failed: ${error instanceof Error ? error.message : String(error)}`,
+        pack_hits: [], results: [], total: 0, truncated: false };
+    }
+  }
   const vault = opts.vault ?? discoverObsidianVault();
   const notices: string[] = [];
   if (vault.isSimulated) {
@@ -75,13 +91,15 @@ export function buildKnowledgeQueryTool(): LLMToolSpec {
   return {
     name: 'KnowledgeQuery',
     description:
-      'Search the Obsidian knowledge vault (or simulated fallback) for notes matching tags, fulltext regex, '
+      'Search an explicitly installed knowledge pack by pack_id and question for cited cards, or search the Obsidian knowledge vault (or simulated fallback) for notes matching tags, fulltext regex, '
       + 'or kind. Returns paths + parsed frontmatter + excerpts (and optionally full body). Use this to look '
       + 'up prior incident analyses, tool docs, repo maps, or any markdown you or another agent wrote earlier. '
       + 'For writing, use KnowledgeWrite.',
     parameters: {
       type: 'object',
       properties: {
+        pack_id: { type: 'string', description: 'Installed pack id, e.g. pack:semiconductor-process-public@0.1.0. Requires question.' },
+        question: { type: 'string', description: 'Search words when pack_id is provided.' },
         tags: {
           type: 'array',
           items: { type: 'string' },