---
id: wiki-2026-0508-readme
title: README — General Knowledge
category: 10_Wiki/Topics
status: verified
canonical_id: self
aliases: [P-REINFORCE-AUTO-698D8B]
duplicate_of: none
source_trust_level: A
confidence_score: 0.95
verification_status: applied
tags: [readme, index, meta]
raw_sources: []
last_reinforced: 2026-05-10
github_commit: pending
---

# README — General Knowledge

## 매 한 줄
> **"매 cross-domain knowledge 의 hub"**. 매 General Knowledge folder 는 narrowly-scoped 도메인에 fit 하지 않은 wiki note 의 catch-all index — game design, web platform, ML theory, neuroscience 가 cross-pollinate 한다.

## 매 핵심

### 매 폴더 목적
- 매 cross-domain note 의 home — 매 specific topic folder (AI_and_ML, Programming) 에 fit 하지 않은 entry.
- 매 case study + concept primer 의 mix.
- 매 canonical 문서 + redirect 문서 의 coexist.

### 매 분류 체계
- 매 status: `verified` (canonical), `duplicate` (redirect), `merged` (filename-level redirect), `needs_review` (pending cleanup).
- 매 canonical_id: `self` (own canonical) or external canonical slug.
- 매 frontmatter 의 일관된 schema — id, title, category, status, canonical_id, aliases, source_trust_level.

### 매 응용
1. Game design knowledge base — Albion Online, Clash Royale, Diablo 2 의 case study.
2. Web platform primer — OffscreenCanvas, SharedArrayBuffer 의 깊이 있는 reference.
3. Cognitive science index — Dopamine Signaling, Mycological Horror 의 cross-cut topic.

## 💻 패턴

### 패턴 1: Frontmatter linting
```python
import yaml
import frontmatter
from pathlib import Path

REQUIRED = {"id", "title", "category", "status", "canonical_id"}

def lint_folder(folder: Path):
    issues = []
    for md in folder.glob("*.md"):
        post = frontmatter.load(md)
        missing = REQUIRED - set(post.metadata.keys())
        if missing:
            issues.append((md.name, f"missing: {missing}"))
    return issues

for name, issue in lint_folder(Path("./General Knowledge")):
    print(f"{name}: {issue}")
```

### 패턴 2: Duplicate detection (title similarity)
```python
from rapidfuzz import fuzz
from pathlib import Path
import frontmatter

def find_dupes(folder: Path, threshold=85):
    titles = []
    for md in folder.glob("*.md"):
        post = frontmatter.load(md)
        titles.append((md.name, post.metadata.get("title", "")))

    pairs = []
    for i, (n1, t1) in enumerate(titles):
        for n2, t2 in titles[i+1:]:
            score = fuzz.ratio(t1, t2)
            if score >= threshold:
                pairs.append((n1, n2, score))
    return pairs
```

### 패턴 3: Wikilink graph build
```python
import re
import networkx as nx
from pathlib import Path

LINK_RE = re.compile(r"\[\[([^\]]+)\]\]")

def build_graph(folder: Path) -> nx.DiGraph:
    g = nx.DiGraph()
    for md in folder.glob("*.md"):
        text = md.read_text()
        for target in LINK_RE.findall(text):
            g.add_edge(md.stem, target.split("|")[0])
    return g

g = build_graph(Path("./General Knowledge"))
print(f"nodes={g.number_of_nodes()} edges={g.number_of_edges()}")
print("orphans:", [n for n in g.nodes if g.in_degree(n) == 0])
```

### 패턴 4: Redirect resolution
```python
def resolve(slug: str, index: dict[str, dict]) -> str:
    seen = set()
    cur = slug
    while cur in index and index[cur].get("status") in ("duplicate", "merged"):
        if cur in seen:
            raise ValueError(f"redirect cycle at {cur}")
        seen.add(cur)
        cur = index[cur].get("canonical_id") or index[cur].get("redirect_to")
    return cur
```

### 패턴 5: Reinforcement scheduler
```python
from datetime import date, timedelta

def needs_reinforcement(meta: dict, today: date = date.today()) -> bool:
    last = date.fromisoformat(meta["last_reinforced"])
    score = float(meta.get("confidence_score", 0.9))
    interval = timedelta(days=30 if score >= 0.9 else 14)
    return today - last > interval
```

## 매 결정 기준
| 상황 | Approach |
|---|---|
| 새 note 의 fit folder 가 명확 | specific folder 에 add (not General Knowledge) |
| cross-domain note | General Knowledge |
| Korean title duplicate | REDIRECT to English canonical |
| stub / placeholder | redirect to README |

**기본값**: domain-specific folder 우선, fallback 만 General Knowledge.

## 🔗 Graph
- 부모: [[Wiki Index]] · [[10_Wiki/Topics]]
- 변형: [[AI_and_ML/README]] · [[Programming & Language/README]]

## 🤖 LLM 활용
**언제**: cross-domain question 의 routing, knowledge graph 구축, reinforcement scheduling.
**언제 X**: 매 specific domain 의 deep query — domain folder 의 직접 lookup 우선.

## ❌ 안티패턴
- **Catch-all dumping**: 매 note 가 specific folder 의 candidate 인데 General Knowledge 에 dump — graph 의 fragmentation.
- **Redirect chain**: 매 redirect → redirect → canonical 의 multi-hop. 매 single-hop 으로 flatten.
- **Stale frontmatter**: 매 last_reinforced 의 90+일 미갱신 — reinforcement loop 의 break.

## 🧪 검증 / 중복
- Verified (folder ls + frontmatter lint).
- 신뢰도 A (meta-doc, self-describing).

## 🕓 Changelog
| 날짜 | 변경 |
|---|---|
| 2026-05-08 | Phase 1 |
| 2026-05-10 | Manual cleanup — README 의 substantive content 화 |
