claude-memory-layer 1.0.26 → 1.0.28

package/memory/specs/entity-edge-model/2026-02-25.md

@@ -1,1263 +0,0 @@
-
-## 2026-02-25T12:31:26.264Z | c2863c93-7c09-49be-b0df-8e7a10a76195
-- type: session_summary
-- session: import:organized
-# Entity-Edge Model Context
-
-> **Version**: 1.0.0
-> **Created**: 2026-01-31
-
-## 1. 배경
-
-### 1.1 그래프 기반 지식 표현의 필요성
-
-지식 시스템에서 관계(relationship)는 노드만큼 중요합니다:
-
-- **Fact A**가 **Task B**의 증거가 된다
-- **Task C**가 **Condition D**에 의해 blocked 되어있다
-- **Entry E**가 **Entry F**를 대체(supersede)한다
-
-이런 관계를 JSON 내부에 저장하면:
-1. 쿼리가 복잡해짐 (JSON 파싱 필요)
-2. 일관성 보장 어려움 (양방향 관계)
-3. 성능 저하 (인덱스 활용 불가)
-
-### 1.2 Property Graph 모델
-
-```
-(Entry)-[:EVIDENCE_OF]->(Entity)
-(Entity)-[:BLOCKED_BY]->(Entity)
-(Entry)-[:DERIVED_FROM]->(Entry)
-```
-
-**장점**:
-- 관계가 1급 시민 (first-class citizen)
-- 인덱스를 통한 빠른 탐색
-- 복잡한 경로 쿼리 가능 (e.g., 증거 체인)
-
-## 2. Memo.txt 참고 사항
-
-### 2.1 스키마 분리 (섹션 4)
-
-> **entries / entities / edges 분리**
-> - entries: 불변 기록
-> - entities: 상태 변화 개체
-> - edges: 관계 그래프
-
-### 2.2 edges 테이블 (섹션 4.3)
-
-```sql
-CREATE TABLE edges (
-  edge_id     VARCHAR PRIMARY KEY,
-  src_type    VARCHAR NOT NULL,  -- entry|entity
-  src_id      VARCHAR NOT NULL,
-  rel_type    VARCHAR NOT NULL,  -- evidence_of|blocked_by|...
-  dst_type    VARCHAR NOT NULL,
-  dst_id      VARCHAR NOT NULL,
-  meta_json   JSON,
-  created_at  TIMESTAMP DEFAULT CURRENT_TIMESTAMP
-);
-```
-
-### 2.3 관계 타입
-
-**Entity ↔ Entity**:
-- `blocked_by`: 확정된 blocker
-- `blocked_by_suggested`: 제안된 blocker (미확정)
-- `resolves_to`: Condition이 실제 Entity로 해결
-
-**Entry ↔ Entity**:
-- `evidence_of`: Entry가 Entity의 증거
-
-### 2.4 Effective Blockers (섹션 9.1)
-
-> **v_task_blockers_effective 뷰**:
-> blocked_by edge의 대상이 condition이고 resolves_to가 있으면
-> effective blocker를 resolved_to로 펼쳐서 반환
-
-## 3. Idris2 영감 적용
-
-### 3.1 Dependent Types로 관계 제약
-
-**Idris2 개념**:
-```idris
--- 타입 수준에서 유효한 관계만 허용
-data Edge : NodeType -> RelationType -> NodeType -> Type where
-  EvidenceOf : (src : Entry) -> (dst : Entity) -> Edge Entry EvidenceOf Entity
-  BlockedBy  : (src : Task) -> (dst : Entity) -> Edge Entity BlockedBy Entity
-```
-
-**TypeScript 적용**:
-```typescript
-// Discriminated Union으로 유효 조합 정의
-type ValidEdge =
-  | { srcType: 'entry'; relType: 'evidence_of'; dstType: 'entity' }
-  | { srcType: 'entity'; relType: 'blocked_by'; dstType: 'entity' }
-  | { srcType: 'entity'; relType: 'resolves_to'; dstType: 'entity' };
-
-// 타입 가드
-function isValidEdge(edge: EdgeInput): edge is ValidEdge {
-  const patterns: ValidEdge[] = [ ... ];
-  return patterns.some(p =>
-    p.srcType === edge.srcType &&
-    p.relType === edge.relType &&
-    p.dstType === edge.dstType
-  );
-}
-```
-
-### 3.2 관계 불변식
-
-```typescript
-// 불변식: blocked_by edge가 있으면 Task는 blocked 상태여야 함
-const BlockedByInvariant = z.object({
-  task: z.object({
-    status: z.literal('blocked')
-  }),
-  edges: z.array(z.object({
-    relType: z.literal('blocked_by')
-  })).min(1)  // 최소 1개의 blocker
-});
-
-// 불변식: done 상태면 blocked_by edge가 없어야 함
-const DoneInvariant = z.object({
-  task: z.object({
-    status: z.literal('done')
-  }),
-  edges: z.array(z.object({
-    relType: z.literal('blocked_by')
-  })).max(0)  // blocker 없음
-});
-```
-
-### 3.3 양방향 탐색 안전성
-
-```typescript
-// Idris2: 양방향 탐색이 타입 안전
-interface BidirectionalEdge<S, R, D> {
-  from(src: S): Edge<S, R, D>[];
-  to(dst: D): Edge<S, R, D>[];
-
-  // 불변식: from(x).filter(e => e.dst === y) === to(y).filter(e => e.src === x)
-}
-
-// TypeScript: 인덱스로 보장
-// idx_edges_src: (src_id, rel_type)
-// idx_edges_dst: (dst_id, rel_type)
-```
-
-## 4. 기존 코드와의 관계
-
-### 4.1 types.ts
-
-현재 Edge 관련 타입 없음 → 추가 필요:
-
-```typescript
-// 현재
-export const EvidenceSpanSchema = z.object({
-  start: z.number(),
-  end: z.number(),
-  confidence: z.number(),
-  matchType: z.enum(['exact', 'fuzzy', 'none']),
-  ...
-});
-
-// 추가
-export const EdgeSchema = z.object({
-  edgeId: z.string(),
-  srcType: NodeTypeSchema,
-  srcId: z.string(),
-  relType: RelationTypeSchema,
-  dstType: NodeTypeSchema,
-  dstId: z.string(),
-  metaJson: z.record(z.unknown()).optional()
-});
-```
-
-### 4.2 event-store.ts
-
-Edge 생성은 Projector가 담당, EventStore와 직접 연관 없음.
-단, source_of edge를 통해 이벤트와 Entry/Entity 연결 가능:
-
-```typescript
-// 세션 이벤트와 생성된 Entry 연결
-edges.create({
-  srcType: 'event',
-  srcId: sessionIngestedEvent.id,
-  relType: 'source_of',
-  dstType: 'entry',
-  dstId: newEntry.id
-});
-```
-
-### 4.3 matcher.ts
-
-현재 Matcher는 이벤트 매칭용 → Entity 매칭으로 확장 시 edge 활용:
-
-```typescript
-// Entity 검색 시 관계 정보도 반환
-async function findTaskWithRelations(taskId: string): Promise<TaskWithRelations> {
-  const task = await entityRepo.findById(taskId);
-  const blockedByEdges = await edgeRepo.findBySrc(taskId, 'blocked_by');
-  const evidenceEdges = await edgeRepo.findByDst(taskId, 'evidence_of');
-
-  return {
-    ...task,
-    blockers: blockedByEdges.map(e => e.dstId),
-    evidence: evidenceEdges.map(e => e.srcId)
-  };
-}
-```
-
-## 5. 설계 결정 사항
-
-### 5.1 왜 별도 edges 테이블인가?
-
-**대안 1: JSON 내 저장**
-```json
-{
-  "id": "task_1",
-  "blockers": ["cond_a", "task_b"]
-}
-```
-- 단점: 역방향 쿼리 어려움 ("cond_a를 blocker로 가진 Task는?")
-
-**대안 2: 관계형 테이블**
-```sql
-CREATE TABLE task_blockers (
-  task_id VARCHAR,
-  blocker_id VARCHAR
-);
-```
-- 단점: 관계 타입마다 테이블 필요
-
-**선택: 범용 edges 테이블**
-- 장점: 모든 관계를 하나의 패턴으로 처리
-- 장점: 메타데이터 유연하게 저장
-- 장점: 인덱스로 양방향 탐색 최적화
-
-### 5.2 왜 meta_json을 사용하는가?
-
-관계마다 필요한 메타데이터가 다름:
-
-```typescript
-// evidence_of: span, confidence, method
-{ span: { start: 10, end: 50 }, confidence: 0.95, method: 'fuzzy' }
-
-// blocked_by: mode, raw_text
-{ mode: 'suggest', raw_text: '인증 API 완료 필요' }
-
-// resolves_to: resolution_type, resolved_at
-{ resolution_type: 'exact_match', resolved_at: '2026-01-31T10:00:00Z' }
-```
-
-JSON 컬럼으로 유연하게 처리.
-
-### 5.3 중복 방지 전략
-
-**Unique 인덱스**:
-```sql
-CREATE UNIQUE INDEX idx_edges_unique
-ON edges(src_type, src_id, rel_type, dst_type, dst_id);
-```
-
-**INSERT OR IGNORE / ON CONFLICT**:
-```sql
-INSERT INTO edges (...)
-VALUES (...)
-ON CONFLICT (src_type, src_id, rel_type, dst_type, dst_id)
-DO NOTHING;  -- 또는 UPDATE meta_json
-```
-
-## 6. 쿼리 패턴 예시
-
-### 6.1 Task의 모든 관계 조회
-
-```sql
--- Task를 중심으로 한 모든 관계
-SELECT
-  'outgoing' AS direction,
-  e.rel_type,
-  e.dst_type,
-  e.dst_id,
-  e.meta_json
-FROM edges e
-WHERE e.src_type = 'entity' AND e.src_id = :task_id
-
-UNION ALL
-
-SELECT
-  'incoming' AS direction,
-  e.rel_type,
-  e.src_type,
-  e.src_id,
-  e.meta_json
-FROM edges e
-WHERE e.dst_type = 'entity' AND e.dst_id = :task_id;
-```
-
-### 6.2 Blocked Tasks 조회 (blocker 정보 포함)
-
-```sql
-SELECT
-  t.entity_id AS task_id,
-  t.title AS task_title,
-  JSON_GROUP_ARRAY(
-    JSON_OBJECT(
-      'blocker_id', e.dst_id,
-      'blocker_type', ent.entity_type,
-      'blocker_title', ent.title
-    )
-  ) AS blockers
-FROM entities t
-JOIN edges e ON e.src_id = t.entity_id AND e.rel_type = 'blocked_by'
-JOIN entities ent ON ent.entity_id = e.dst_id
-WHERE t.entity_type = 'task'
-  AND JSON_EXTRACT(t.current_json, '$.status') = 'blocked'
-GROUP BY t.entity_id;
-```
-
-### 6.3 증거 체인 탐색 (2-hop)
-
-```sql
--- Entry → Entity → 관련 Entry
-WITH first_hop AS (
-  SELECT
-    e1.src_id AS entry_id,
-    e1.dst_id AS entity_id
-  FROM edges e1
-  WHERE e1.src_type = 'entry'
-    AND e1.rel_type = 'evidence_of'
-    AND e1.src_id = :start_entry_id
-),
-second_hop AS (
-  SELECT
-    f.entry_id AS origin_entry,
-    f.entity_id,
-    e2.src_id AS related_entry_id
-  FROM first_hop f
-  JOIN edges e2 ON e2.dst_id = f.entity_id
-               AND e2.rel_type = 'evidence_of'
-               AND e2.src_type = 'entry'
-  WHERE e2.src_id != f.entry_id  -- 자기 자신 제외
-)
-SELECT * FROM second_hop;
-```
-
-## 7. 성능 고려사항
-
-### 7.1 인덱스 전략
-
-```sql
--- 출발점 기준 탐색 (가장 빈번)
-CREATE INDEX idx_edges_src ON edges(src_id, rel_type);
-
--- 도착점 기준 탐색 (역방향)
-CREATE INDEX idx_edges_dst ON edges(dst_id, rel_type);
-
--- 관계 타입별 통계
-CREATE INDEX idx_edges_rel ON edges(rel_type);
-```
-
-### 7.2 캐싱
-
-```typescript
-// 자주 조회되는 관계 캐싱
-const relationCache = new LRUCache<string, Edge[]>({
-  max: 5000,
-  ttl: 1000 * 60 * 5  // 5분
-});
-
-async function getBlockers(taskId: string): Promise<Edge[]> {
-  const key = `blockers:${taskId}`;
-  if (relationCache.has(key)) {
-    return relationCache.get(key)!;
-  }
-
-  const edges = await edgeRepo.findBySrc(taskId, 'blocked_by');
-  relationCache.set(key, edges);
-  return edges;
-}
-```
-
-### 7.3 배치 처리
-
-```typescript
-// 대량 edge 생성 시 배치 insert
-async function createManyEdges(edges: EdgeInput[]): Promise<void> {
-  const BATCH_SIZE = 1000;
-
-  for (let i = 0; i < edges.length; i += BATCH_SIZE) {
-    const batch = edges.slice(i, i + BATCH_SIZE);
-    await db.transaction(async (tx) => {
-      for (const edge of batch) {
-        await tx.run('INSERT INTO edges ...', [...]);
-      }
-    });
-  }
-}
-```
-
-## 8. 참고 자료
-
-- **Memo.txt**: 섹션 4.3 (edges 테이블), 섹션 9.1 (effective blockers)
-- **Property Graph**: Neo4j, AWS Neptune 모델 참고
-- **AXIOMMIND**: Principle 5 (Task는 Entity)
-
-## 2026-02-25T12:31:26.271Z | 1da4a9f2-dafe-499d-a329-ec6a7a366cc5
-- type: session_summary
-- session: import:organized
-# Entity-Edge Model Implementation Plan
-
-> **Version**: 1.0.0
-> **Status**: Draft
-> **Created**: 2026-01-31
-
-## Phase 1: 스키마 정의 (P0)
-
-### 1.1 타입 정의
-
-**파일**: `src/core/types.ts` 수정
-
-```typescript
-// 추가할 타입들
-export const NodeTypeSchema = z.enum(['entry', 'entity', 'event']);
-export type NodeType = z.infer<typeof NodeTypeSchema>;
-
-export const RelationTypeSchema = z.enum([
-  // Entry ↔ Entry
-  'derived_from',
-  'supersedes',
-  'contradicts',
-  // Entry ↔ Entity
-  'evidence_of',
-  'mentions',
-  // Entity ↔ Entity
-  'blocked_by',
-  'blocked_by_suggested',
-  'resolves_to',
-  'depends_on',
-  // Event ↔ Entry/Entity
-  'produced',
-  'source_of'
-]);
-export type RelationType = z.infer<typeof RelationTypeSchema>;
-
-export const EdgeSchema = z.object({
-  edgeId: z.string(),
-  srcType: NodeTypeSchema,
-  srcId: z.string(),
-  relType: RelationTypeSchema,
-  dstType: NodeTypeSchema,
-  dstId: z.string(),
-  metaJson: z.record(z.unknown()).optional(),
-  createdAt: z.date()
-});
-export type Edge = z.infer<typeof EdgeSchema>;
-```
-
-**작업 항목**:
-- [ ] NodeType 스키마 추가
-- [ ] RelationType 스키마 추가
-- [ ] Edge 스키마 추가
-- [ ] EdgeMeta 타입들 추가 (EvidenceOfMeta, BlockedByMeta 등)
-
-### 1.2 DB 스키마
-
-**파일**: 마이그레이션 스크립트
-
-```sql
--- 신규 테이블
-CREATE TABLE edges (...);
-
--- entries 테이블 수정 (필요시)
-ALTER TABLE entries ADD COLUMN IF NOT EXISTS superseded_by VARCHAR;
-
--- 인덱스
-CREATE INDEX idx_edges_src ON edges(src_id, rel_type);
-CREATE INDEX idx_edges_dst ON edges(dst_id, rel_type);
-CREATE UNIQUE INDEX idx_edges_unique ON edges(src_type, src_id, rel_type, dst_type, dst_id);
-```
-
-**작업 항목**:
-- [ ] edges 테이블 DDL
-- [ ] 인덱스 생성
-- [ ] 중복 방지 unique 인덱스
-
-## Phase 2: EdgeRepository 구현 (P0)
-
-### 2.1 기본 CRUD
-
-**파일**: `src/core/edge-repo.ts` (신규)
-
-```typescript
-export class EdgeRepository {
-  constructor(private db: Database);
-
-  async create(edge: EdgeInput): Promise<Edge> {
-    const edgeId = uuidv4();
-    await this.db.run(`
-      INSERT INTO edges (edge_id, src_type, src_id, rel_type, dst_type, dst_id, meta_json)
-      VALUES (?, ?, ?, ?, ?, ?, ?)
-    `, [edgeId, edge.srcType, edge.srcId, edge.relType, edge.dstType, edge.dstId,
-        JSON.stringify(edge.metaJson || {})]);
-    return { edgeId, ...edge, createdAt: new Date() };
-  }
-
-  async createMany(edges: EdgeInput[]): Promise<Edge[]> {
-    // 배치 insert
-  }
-}
-```
-
-**작업 항목**:
-- [ ] create() 메서드
-- [ ] createMany() 배치 메서드
-- [ ] findById() 메서드
-- [ ] findBySrc() 메서드
-- [ ] findByDst() 메서드
-
-### 2.2 삭제 및 교체
-
-```typescript
-async deleteBySrc(srcId: string, relType: string): Promise<number> {
-  const result = await this.db.run(`
-    DELETE FROM edges WHERE src_id = ? AND rel_type = ?
-  `, [srcId, relType]);
-  return result.changes;
-}
-
-async replaceBySrc(
-  srcId: string,
-  relType: string,
-  newEdges: EdgeInput[]
-): Promise<void> {
-  await this.db.transaction(async (tx) => {
-    await tx.run('DELETE FROM edges WHERE src_id = ? AND rel_type = ?', [srcId, relType]);
-    for (const edge of newEdges) {
-      await tx.run('INSERT INTO edges ...', [...]);
-    }
-  });
-}
-```
-
-**작업 항목**:
-- [ ] deleteById() 메서드
-- [ ] deleteBySrc() 메서드
-- [ ] replaceBySrc() 트랜잭션 메서드
-- [ ] exists() 중복 확인 메서드
-
-### 2.3 유효성 검증
-
-```typescript
-// 유효한 관계 조합만 허용
-const VALID_EDGE_PATTERNS = [
-  { srcType: 'entry', relType: 'evidence_of', dstType: 'entity' },
-  { srcType: 'entry', relType: 'derived_from', dstType: 'entry' },
-  { srcType: 'entity', relType: 'blocked_by', dstType: 'entity' },
-  // ...
-];
-
-function validateEdge(edge: EdgeInput): boolean {
-  return VALID_EDGE_PATTERNS.some(p =>
-    p.srcType === edge.srcType &&
-    p.relType === edge.relType &&
-    p.dstType === edge.dstType
-  );
-}
-```
-
-**작업 항목**:
-- [ ] 유효 패턴 정의
-- [ ] validateEdge() 함수
-- [ ] create() 호출 시 검증 적용
-
-## Phase 3: 뷰 및 쿼리 (P0)
-
-### 3.1 Effective Blockers 뷰
-
-**파일**: SQL 마이그레이션
-
-```sql
-CREATE VIEW v_task_blockers_effective AS
-WITH blocked AS (
-  SELECT
-    ed.src_id AS task_id,
-    ed.dst_id AS blocker_id,
-    ent.entity_type AS blocker_type,
-    ed.meta_json
-  FROM edges ed
-  JOIN entities ent ON ent.entity_id = ed.dst_id
-  WHERE ed.src_type = 'entity'
-    AND ed.rel_type = 'blocked_by'
-),
-resolved AS (
-  SELECT
-    b.task_id,
-    COALESCE(r.dst_id, b.blocker_id) AS effective_blocker_id,
-    COALESCE(
-      (SELECT entity_type FROM entities WHERE entity_id = r.dst_id),
-      b.blocker_type
-    ) AS effective_blocker_type
-  FROM blocked b
-  LEFT JOIN edges r ON r.src_type = 'entity'
-                   AND r.src_id = b.blocker_id
-                   AND r.rel_type = 'resolves_to'
-)
-SELECT * FROM resolved;
-```
-
-**작업 항목**:
-- [ ] v_task_blockers_effective 뷰 생성
-
-### 3.2 조회 함수
-
-**파일**: `src/core/queries.ts` (신규 또는 기존 확장)
-
-```typescript
-// Task의 effective blockers 조회
-async function getEffectiveBlockers(taskId: string): Promise<EffectiveBlocker[]> {
-  return db.query(`
-    SELECT * FROM v_task_blockers_effective WHERE task_id = ?
-  `, [taskId]);
-}
-
-// Entry의 증거 체인 조회
-async function getEvidenceChain(entryId: string): Promise<Evidence[]> {
-  return db.query(`
-    SELECT ent.*, ed.meta_json as evidence_meta
-    FROM entities ent
-    JOIN edges ed ON ed.dst_id = ent.entity_id
-    WHERE ed.src_type = 'entry' AND ed.src_id = ?
-      AND ed.rel_type = 'evidence_of'
-  `, [entryId]);
-}
-```
-
-**작업 항목**:
-- [ ] getEffectiveBlockers() 함수
-- [ ] getEvidenceChain() 함수
-- [ ] getBlockedTasks() 함수
-- [ ] getResolvedConditions() 함수
-
-## Phase 4: Projector 연동 (P0)
-
-### 4.1 TaskProjector 수정
-
-**파일**: `src/core/task-projector.ts`
-
-```typescript
-// mode=replace 처리
-async handleBlockersSet(event: TaskEvent): Promise<void> {
-  const payload = event.payload as TaskBlockersSetPayload;
-
-  if (payload.mode === 'replace') {
-    // 기존 blocked_by edge 모두 삭제
-    await this.edgeRepo.deleteBySrc(payload.task_id, 'blocked_by');
-
-    // 새 edge 생성
-    for (const blocker of payload.blockers) {
-      await this.edgeRepo.create({
-        srcType: 'entity',
-        srcId: payload.task_id,
-        relType: 'blocked_by',
-        dstType: 'entity',
-        dstId: blocker.entity_id,
-        metaJson: {
-          mode: 'replace',
-          raw_text: blocker.raw_text,
-          confidence: blocker.confidence
-        }
-      });
-    }
-  } else if (payload.mode === 'suggest') {
-    // blocked_by_suggested edge만 추가/갱신
-    await this.edgeRepo.replaceBySrc(
-      payload.task_id,
-      'blocked_by_suggested',
-      payload.blockers.map(b => ({
-        srcType: 'entity',
-        srcId: payload.task_id,
-        relType: 'blocked_by_suggested',
-        dstType: 'entity',
-        dstId: b.entity_id,
-        metaJson: { raw_text: b.raw_text }
-      }))
-    );
-  }
-}
-```
-
-**작업 항목**:
-- [ ] handleBlockersSet에서 edge 생성
-- [ ] mode=replace 처리
-- [ ] mode=suggest 처리
-- [ ] handleStatusChanged에서 done 시 edge 삭제
-
-### 4.2 Evidence Edge 생성
-
-**파일**: `src/core/graduation.ts` 또는 별도 projector
-
-```typescript
-// Entry 저장 시 evidence edge 생성
-async function materializeEntry(entry: Entry, alignResult: AlignResult): Promise<void> {
-  // Entry 저장
-  await entryRepo.create(entry);
-
-  // Evidence edge 생성
-  for (const ev of alignResult.alignedEvidence) {
-    if (ev.matchMethod !== 'none') {
-      // Entity 찾기 또는 생성
-      const entity = await resolveEvidenceTarget(ev);
-
-      await edgeRepo.create({
-        srcType: 'entry',
-        srcId: entry.entry_id,
-        relType: 'evidence_of',
-        dstType: 'entity',
-        dstId: entity.entity_id,
-        metaJson: {
-          confidence: ev.confidence,
-          span: { start: ev.spanStart, end: ev.spanEnd },
-          alignment_method: ev.matchMethod
-        }
-      });
-    }
-  }
-}
-```
-
-**작업 항목**:
-- [ ] Entry 저장 시 evidence edge 생성
-- [ ] source_of edge 생성 (세션 이벤트 연결)
-
-## Phase 5: 마이그레이션 (P1)
-
-### 5.1 기존 데이터 변환 스크립트
-
-**파일**: `scripts/migrate-to-edges.ts`
-
-```typescript
-async function migrateExistingData(): Promise<MigrationResult> {
-  const stats = { entries: 0, edges: 0, errors: 0 };
-
-  // 1. evidence_json → evidence_of edge
-  const entriesWithEvidence = await db.query(`
-    SELECT * FROM entries WHERE evidence_json IS NOT NULL
-  `);
-
-  for (const entry of entriesWithEvidence) {
-    try {
-      const evidence = JSON.parse(entry.evidence_json);
-      // ... edge 생성
-      stats.edges++;
-    } catch (e) {
-      stats.errors++;
-    }
-  }
-
-  // 2. Task blockers → blocked_by edge
-  const tasks = await db.query(`
-    SELECT * FROM entities WHERE entity_type = 'task'
-  `);
-
-  for (const task of tasks) {
-    const currentJson = JSON.parse(task.current_json);
-    if (currentJson.blockers) {
-      // ... edge 생성
-    }
-  }
-
-  return stats;
-}
-```
-
-**작업 항목**:
-- [ ] evidence_json → edge 변환
-- [ ] Task blockers → edge 변환
-- [ ] 변환 통계 리포트
-- [ ] 롤백 스크립트
-
-### 5.2 이중 쓰기 기간
-
-```typescript
-// 마이그레이션 기간 동안 JSON과 edge 모두 기록
-async function createBlockerWithDualWrite(
-  taskId: string,
-  blockers: BlockerRef[]
-): Promise<void> {
-  // 1. 기존 방식: current_json에 blockers 저장
-  await entityRepo.updateCurrentState(taskId, { blockers });
-
-  // 2. 신규 방식: edge 생성
-  for (const b of blockers) {
-    await edgeRepo.create({ ... });
-  }
-}
-```
-
-**작업 항목**:
-- [ ] 이중 쓰기 래퍼 함수
-- [ ] 마이그레이션 완료 후 JSON 쓰기 제거
-
-## 파일 목록
-
-### 신규 파일
-```
-src/core/edge-repo.ts         # Edge CRUD
-src/core/queries.ts           # 복합 쿼리 함수
-scripts/migrate-to-edges.ts   # 마이그레이션 스크립트
-```
-
-### 수정 파일
-```
-src/core/types.ts             # Edge 타입 추가
-src/core/task-projector.ts    # Edge 생성 연동
-src/core/graduation.ts        # Evidence edge 생성
-```
-
-## 테스트
-
-### 필수 테스트 케이스
-
-1. **Edge 생성 유효성**
-   ```typescript
-   // 유효한 조합
-   await edgeRepo.create({
-     srcType: 'entry', relType: 'evidence_of', dstType: 'entity', ...
-   }); // OK
-
-   // 무효한 조합
-   await edgeRepo.create({
-     srcType: 'entry', relType: 'blocked_by', dstType: 'entry', ...
-   }); // Error
-   ```
-
-2. **중복 방지**
-   ```typescript
-   await edgeRepo.create({ srcId: 'a', dstId: 'b', relType: 'evidence_of', ... });
-   await edgeRepo.create({ srcId: 'a', dstId: 'b', relType: 'evidence_of', ... });
-   // 두 번째는 무시 또는 에러
-   ```
-
-3. **replace 동작**
-   ```typescript
-   await edgeRepo.replaceBySrc('task1', 'blocked_by', [
-     { dstId: 'blocker1' },
-     { dstId: 'blocker2' }
-   ]);
-   // 기존 blocked_by edge 모두 삭제 후 새로 생성
-   ```
-
-4. **Effective blockers**
-   ```typescript
-   // Condition → Task로 resolve된 경우
-   // v_task_blockers_effective에서 Task가 effective blocker로 나와야 함
-   ```
-
-## 마일스톤
-
-| 단계 | 완료 기준 |
-|------|----------|
-| M1 | 타입 정의 + edges 테이블 생성 |
-| M2 | EdgeRepository 기본 CRUD |
-| M3 | v_task_blockers_effective 뷰 |
-| M4 | TaskProjector edge 연동 |
-| M5 | Evidence edge 생성 |
-| M6 | 마이그레이션 스크립트 |
-| M7 | 테스트 통과 |
-
-## 2026-02-25T12:31:26.278Z | d0eb1b33-8169-4aa2-8130-20c12565f585
-- type: session_summary
-- session: import:organized
-# Entity-Edge Model Specification
-
-> **Version**: 1.0.0
-> **Status**: Draft
-> **Created**: 2026-01-31
-
-## 1. 개요
-
-### 1.1 문제 정의
-
-현재 시스템에서 데이터 관계가 명시적으로 모델링되지 않음:
-
-1. **Entry 간 관계 없음**: Fact와 이를 지지하는 Decision이 분리됨
-2. **Entity 관계 없음**: Task와 Blocker 간 관계가 JSON 내부에만 존재
-3. **증거 추적 불가**: Entry가 어떤 세션에서 왔는지 추적 어려움
-
-### 1.2 해결 방향
-
-**entries / entities / edges 분리**:
-- `entries`: 불변 기록 (Fact, Decision, Insight 등)
-- `entities`: 상태 변화 개체 (Task, Condition, Artifact)
-- `edges`: 관계 그래프 (evidence_of, blocked_by 등)
-
-## 2. 핵심 개념
-
-### 2.1 3-Layer 모델
-
-```
-┌─────────────────────────────────────────────────────────────┐
-│                        edges                                 │
-│  ┌──────────┐    evidence_of    ┌──────────┐               │
-│  │  Entry   │ ─────────────────▶│  Entity  │               │
-│  └──────────┘                   └──────────┘               │
-│       │                              │                       │
-│       │ derived_from                 │ blocked_by           │
-│       ▼                              ▼                       │
-│  ┌──────────┐                   ┌──────────┐               │
-│  │  Entry   │                   │  Entity  │               │
-│  └──────────┘                   └──────────┘               │
-└─────────────────────────────────────────────────────────────┘
-```
-
-### 2.2 Node 타입
-
-| 타입 | 테이블 | 예시 |
-|-----|--------|-----|
-| entry | entries | Fact, Decision, Insight, TaskNote |
-| entity | entities | Task, Condition, Artifact |
-| event | events | session_ingested, memory_extracted |
-
-### 2.3 관계 타입
-
-```typescript
-type RelationType =
-  // Entry ↔ Entry
-  | 'derived_from'        // 이 Entry가 다른 Entry에서 파생됨
-  | 'supersedes'          // 이 Entry가 다른 Entry를 대체함
-  | 'contradicts'         // 이 Entry가 다른 Entry와 모순됨
-
-  // Entry ↔ Entity
-  | 'evidence_of'         // Entry가 Entity의 증거
-  | 'mentions'            // Entry가 Entity를 언급
-
-  // Entity ↔ Entity
-  | 'blocked_by'          // Task가 다른 Entity에 의해 blocked
-  | 'blocked_by_suggested'// 제안된 blocker (미확정)
-  | 'resolves_to'         // Condition이 실제 Entity로 해결됨
-  | 'depends_on'          // 일반적인 의존 관계
-
-  // Event ↔ Entry/Entity
-  | 'produced'            // Event가 Entry/Entity를 생성함
-  | 'source_of'           // Event가 증거의 원본 소스
-```
-
-## 3. DB 스키마
-
-### 3.1 entries 테이블
-
-```sql
-CREATE TABLE entries (
-  entry_id      VARCHAR PRIMARY KEY,
-  created_ts    TIMESTAMP NOT NULL,
-  entry_type    VARCHAR NOT NULL,        -- fact|decision|insight|task_note|reference
-  title         VARCHAR NOT NULL,
-  content_json  JSON NOT NULL,
-  stage         VARCHAR NOT NULL,        -- raw|working|candidate|verified|certified
-  status        VARCHAR DEFAULT 'active',-- active|contested|deprecated|superseded
-  superseded_by VARCHAR,                 -- 대체된 경우 새 entry_id
-  build_id      VARCHAR,
-  evidence_json JSON,                    -- aligned spans
-  canonical_key VARCHAR,
-  created_at    TIMESTAMP DEFAULT CURRENT_TIMESTAMP
-);
-
-CREATE INDEX idx_entries_type ON entries(entry_type);
-CREATE INDEX idx_entries_stage ON entries(stage);
-CREATE INDEX idx_entries_status ON entries(status);
-CREATE INDEX idx_entries_canonical ON entries(canonical_key);
-```
-
-### 3.2 entities 테이블
-
-```sql
-CREATE TABLE entities (
-  entity_id      VARCHAR PRIMARY KEY,
-  entity_type    VARCHAR NOT NULL,       -- task|condition|artifact
-  canonical_key  VARCHAR NOT NULL,
-  title          VARCHAR NOT NULL,
-  stage          VARCHAR NOT NULL,       -- raw|working|candidate|verified|certified
-  status         VARCHAR NOT NULL,       -- active|contested|deprecated|superseded
-  current_json   JSON NOT NULL,          -- fold된 현재 상태
-  title_norm     VARCHAR,                -- 정규화된 제목 (검색용)
-  search_text    VARCHAR,                -- FTS용 텍스트
-  created_at     TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-  updated_at     TIMESTAMP DEFAULT CURRENT_TIMESTAMP
-);
-
-CREATE UNIQUE INDEX idx_entities_type_key ON entities(entity_type, canonical_key);
-CREATE INDEX idx_entities_status ON entities(status);
-```
-
-### 3.3 edges 테이블
-
-```sql
-CREATE TABLE edges (
-  edge_id     VARCHAR PRIMARY KEY,
-  src_type    VARCHAR NOT NULL,  -- entry|entity|event
-  src_id      VARCHAR NOT NULL,
-  rel_type    VARCHAR NOT NULL,  -- evidence_of|blocked_by|...
-  dst_type    VARCHAR NOT NULL,  -- entry|entity|event
-  dst_id      VARCHAR NOT NULL,
-  meta_json   JSON,              -- 관계 메타데이터
-  created_at  TIMESTAMP DEFAULT CURRENT_TIMESTAMP
-);
-
--- 복합 인덱스
-CREATE INDEX idx_edges_src ON edges(src_id, rel_type);
-CREATE INDEX idx_edges_dst ON edges(dst_id, rel_type);
-CREATE INDEX idx_edges_rel ON edges(rel_type);
-
--- 중복 방지 (동일 관계 재생성 방지)
-CREATE UNIQUE INDEX idx_edges_unique ON edges(src_type, src_id, rel_type, dst_type, dst_id);
-```
-
-## 4. Edge 메타데이터
-
-### 4.1 evidence_of
-
-```typescript
-interface EvidenceOfMeta {
-  confidence: number;        // 증거 신뢰도
-  span?: {
-    start: number;
-    end: number;
-  };
-  alignment_method: 'exact' | 'normalized' | 'fuzzy';
-  source_event_id: string;   // 원본 세션 이벤트
-}
-```
-
-### 4.2 blocked_by
-
-```typescript
-interface BlockedByMeta {
-  mode: 'replace' | 'suggest';
-  raw_text: string;          // 원본 텍스트
-  resolved_at?: Date;        // 해결된 시간
-  resolved_by?: string;      // 해결한 세션
-}
-```
-
-### 4.3 resolves_to
-
-```typescript
-interface ResolvesToMeta {
-  resolution_type: 'exact_match' | 'user_confirmed' | 'auto_resolved';
-  confidence: number;
-  resolved_at: Date;
-}
-```
-
-## 5. 쿼리 패턴
-
-### 5.1 Entity의 모든 증거 조회
-
-```sql
-SELECT e.*, ed.meta_json
-FROM entries e
-JOIN edges ed ON ed.src_type = 'entry' AND ed.src_id = e.entry_id
-WHERE ed.rel_type = 'evidence_of'
-  AND ed.dst_type = 'entity'
-  AND ed.dst_id = :entity_id
-ORDER BY e.created_ts DESC;
-```
-
-### 5.2 Task의 effective blockers (Condition 해결 적용)
-
-```sql
--- v_task_blockers_effective 뷰
-CREATE VIEW v_task_blockers_effective AS
-WITH blocked AS (
-  -- 직접 blocker
-  SELECT
-    ed.src_id AS task_id,
-    ed.dst_id AS blocker_id,
-    ed.dst_type AS blocker_type,
-    ed.meta_json
-  FROM edges ed
-  WHERE ed.src_type = 'entity'
-    AND ed.rel_type = 'blocked_by'
-),
-resolved AS (
-  -- Condition이 해결된 경우
-  SELECT
-    b.task_id,
-    COALESCE(r.dst_id, b.blocker_id) AS effective_blocker_id,
-    COALESCE(r.dst_type, b.blocker_type) AS effective_blocker_type
-  FROM blocked b
-  LEFT JOIN edges r ON r.src_type = 'entity'
-                   AND r.src_id = b.blocker_id
-                   AND r.rel_type = 'resolves_to'
-)
-SELECT * FROM resolved;
-```
-
-### 5.3 Entry의 파생 체인 (lineage)
-
-```sql
-WITH RECURSIVE lineage AS (
-  -- Base: 시작 entry
-  SELECT entry_id, 0 AS depth
-  FROM entries
-  WHERE entry_id = :start_id
-
-  UNION ALL
-
-  -- Recursive: derived_from 관계 따라가기
-  SELECT e.src_id, l.depth + 1
-  FROM edges e
-  JOIN lineage l ON e.dst_id = l.entry_id
-  WHERE e.rel_type = 'derived_from'
-    AND l.depth < 10  -- 무한 루프 방지
-)
-SELECT * FROM lineage;
-```
-
-## 6. Idris2 영감 적용
-
-### 6.1 관계 타입 안전성
-
-```typescript
-// 타입 레벨에서 유효한 관계만 허용
-type ValidEdge =
-  | { srcType: 'entry'; relType: 'evidence_of'; dstType: 'entity' }
-  | { srcType: 'entry'; relType: 'derived_from'; dstType: 'entry' }
-  | { srcType: 'entity'; relType: 'blocked_by'; dstType: 'entity' }
-  | { srcType: 'entity'; relType: 'resolves_to'; dstType: 'entity' };
-
-// 잘못된 조합은 타입 에러
-// { srcType: 'entry'; relType: 'blocked_by'; dstType: 'entry' }  // Error!
-```
-
-### 6.2 Zod 스키마로 검증
-
-```typescript
-const EdgeSchema = z.discriminatedUnion('relType', [
-  z.object({
-    srcType: z.literal('entry'),
-    relType: z.literal('evidence_of'),
-    dstType: z.literal('entity')
-  }),
-  z.object({
-    srcType: z.literal('entity'),
-    relType: z.literal('blocked_by'),
-    dstType: z.literal('entity')
-  }),
-  // ...
-]);
-```
-
-### 6.3 불변식
-
-```typescript
-// blocked_by edge 생성 시 Task 상태도 blocked여야 함
-async function createBlockedByEdge(
-  taskId: string,
-  blockerId: string
-): Promise<Edge> {
-  const task = await entityRepo.findById(taskId);
-
-  // 불변식 검증
-  if (task.current_json.status !== 'blocked') {
-    throw new InvariantViolationError(
-      `Cannot create blocked_by edge: Task ${taskId} is not in blocked status`
-    );
-  }
-
-  return edgeRepo.create({
-    srcType: 'entity',
-    srcId: taskId,
-    relType: 'blocked_by',
-    dstType: 'entity',
-    dstId: blockerId
-  });
-}
-```
-
-## 7. EdgeRepository API
-
-```typescript
-interface EdgeRepository {
-  // 생성
-  create(edge: EdgeInput): Promise<Edge>;
-  createMany(edges: EdgeInput[]): Promise<Edge[]>;
-
-  // 조회
-  findById(edgeId: string): Promise<Edge | null>;
-  findBySrc(srcId: string, relType?: string): Promise<Edge[]>;
-  findByDst(dstId: string, relType?: string): Promise<Edge[]>;
-
-  // 삭제 (projector용)
-  deleteById(edgeId: string): Promise<void>;
-  deleteBySrc(srcId: string, relType: string): Promise<number>;
-
-  // 교체 (mode=replace용)
-  replaceBySrc(
-    srcId: string,
-    relType: string,
-    newEdges: EdgeInput[]
-  ): Promise<void>;
-
-  // 중복 확인
-  exists(
-    srcType: string,
-    srcId: string,
-    relType: string,
-    dstType: string,
-    dstId: string
-  ): Promise<boolean>;
-}
-```
-
-## 8. 마이그레이션 전략
-
-### 8.1 기존 데이터 변환
-
-```typescript
-// 기존 entry의 evidence → edges로 변환
-async function migrateEvidence(): Promise<void> {
-  const entries = await db.query('SELECT * FROM entries WHERE evidence_json IS NOT NULL');
-
-  for (const entry of entries) {
-    const evidence = JSON.parse(entry.evidence_json);
-
-    for (const ev of evidence) {
-      // Entity 찾기 (canonical_key 기반)
-      const entity = await entityRepo.findByCanonicalKey(
-        'task',
-        ev.canonical_key
-      );
-
-      if (entity) {
-        await edgeRepo.create({
-          srcType: 'entry',
-          srcId: entry.entry_id,
-          relType: 'evidence_of',
-          dstType: 'entity',
-          dstId: entity.entity_id,
-          metaJson: { confidence: ev.confidence, span: ev.span }
-        });
-      }
-    }
-  }
-}
-```
-
-### 8.2 점진적 적용
-
-1. **Phase 1**: edges 테이블 생성, 신규 데이터만 edge 기록
-2. **Phase 2**: 기존 데이터 마이그레이션 (백그라운드)
-3. **Phase 3**: 쿼리를 edges 기반으로 전환
-4. **Phase 4**: 기존 JSON 필드 deprecated
-
-## 9. 성공 기준
-
-- [ ] entries/entities/edges 3개 테이블 분리 동작
-- [ ] evidence_of edge로 Entry→Entity 증거 관계 추적
-- [ ] blocked_by edge로 Task 의존성 그래프 구축
-- [ ] resolves_to edge로 Condition→Entity 해결 추적
-- [ ] v_task_blockers_effective 뷰로 effective blocker 조회
-- [ ] 기존 JSON 기반 관계와 호환 유지