@beomjk/emdd 0.1.0

package/dist/graph/types.d.ts

@@ -0,0 +1,71 @@
+export type NodeType = 'hypothesis' | 'experiment' | 'finding' | 'knowledge' | 'question' | 'decision' | 'episode';
+export type EdgeType = 'supports' | 'contradicts' | 'confirms' | 'spawns' | 'produces' | 'answers' | 'revises' | 'promotes' | 'depends_on' | 'extends' | 'relates_to' | 'informs' | 'part_of' | 'context_for' | 'tests' | 'answers_to' | 'confirmed_by' | 'supported_by' | 'answered_by' | 'spawned_from' | 'produced_by' | 'tested_by';
+export declare const EDGE_TYPES: Set<string>;
+export declare const REVERSE_LABELS: Record<string, string>;
+export declare const ALL_VALID_RELATIONS: Set<string>;
+export declare const NODE_TYPES: NodeType[];
+export declare const NODE_TYPE_DIRS: Record<NodeType, string>;
+export declare const ID_PREFIXES: Record<NodeType, string>;
+export declare const PREFIX_TO_TYPE: Record<string, NodeType>;
+export declare const VALID_STATUSES: Record<NodeType, readonly string[]>;
+export declare const REQUIRED_FIELDS: Record<NodeType, readonly string[]>;
+export interface Link {
+    target: string;
+    relation: string;
+}
+export interface Node {
+    id: string;
+    type: NodeType;
+    title: string;
+    path: string;
+    status?: string;
+    confidence?: number;
+    tags: string[];
+    links: Link[];
+    meta: Record<string, unknown>;
+}
+export interface Graph {
+    nodes: Map<string, Node>;
+    errors: string[];
+    warnings: string[];
+}
+export interface NodeFilter {
+    type?: NodeType;
+    status?: string;
+}
+export interface NodeDetail extends Node {
+    body: string;
+}
+export interface CreateNodeResult {
+    id: string;
+    type: NodeType;
+    path: string;
+}
+export interface CreateEdgeResult {
+    source: string;
+    target: string;
+    relation: string;
+}
+export interface HealthReport {
+    totalNodes: number;
+    totalEdges: number;
+    byType: Record<string, number>;
+    statusDistribution: Record<string, Record<string, number>>;
+    avgConfidence: number | null;
+    openQuestions: number;
+    linkDensity: number;
+    gaps: string[];
+}
+export interface CheckTrigger {
+    type: string;
+    message: string;
+    count?: number;
+}
+export interface CheckResult {
+    triggers: CheckTrigger[];
+}
+export interface PromoteCandidate {
+    id: string;
+    confidence: number;
+    supports: number;
+}

package/dist/graph/types.js

@@ -0,0 +1,70 @@
+// ── Node Types ──────────────────────────────────────────────────────
+export const EDGE_TYPES = new Set([
+    // evidence
+    'supports', 'contradicts', 'confirms',
+    // generation
+    'spawns', 'produces', 'answers', 'revises', 'promotes',
+    // structure
+    'depends_on', 'extends', 'relates_to', 'informs',
+    // composition
+    'part_of', 'context_for',
+    // aliases
+    'tests', 'answers_to',
+]);
+export const REVERSE_LABELS = {
+    confirmed_by: 'confirms',
+    supported_by: 'supports',
+    answered_by: 'answers',
+    spawned_from: 'spawns',
+    produced_by: 'produces',
+    tested_by: 'tests',
+};
+export const ALL_VALID_RELATIONS = new Set([
+    ...EDGE_TYPES,
+    ...Object.keys(REVERSE_LABELS),
+]);
+export const NODE_TYPES = [
+    'hypothesis', 'experiment', 'finding', 'knowledge',
+    'question', 'decision', 'episode',
+];
+// ── Node Type → Directory Mapping ───────────────────────────────────
+export const NODE_TYPE_DIRS = {
+    hypothesis: 'hypotheses',
+    experiment: 'experiments',
+    finding: 'findings',
+    knowledge: 'knowledge',
+    question: 'questions',
+    decision: 'decisions',
+    episode: 'episodes',
+};
+// ── ID Prefixes ─────────────────────────────────────────────────────
+export const ID_PREFIXES = {
+    hypothesis: 'hyp',
+    experiment: 'exp',
+    finding: 'fnd',
+    knowledge: 'knw',
+    question: 'qst',
+    decision: 'dec',
+    episode: 'epi',
+};
+export const PREFIX_TO_TYPE = Object.fromEntries(Object.entries(ID_PREFIXES).map(([type, prefix]) => [prefix, type]));
+// ── Valid Statuses per Node Type ────────────────────────────────────
+export const VALID_STATUSES = {
+    hypothesis: ['PROPOSED', 'TESTING', 'SUPPORTED', 'REFUTED', 'REVISED', 'DEFERRED'],
+    experiment: ['PLANNED', 'RUNNING', 'COMPLETED', 'FAILED', 'ABANDONED'],
+    finding: ['DRAFT', 'VALIDATED', 'PROMOTED', 'RETRACTED'],
+    knowledge: ['ACTIVE', 'DISPUTED', 'SUPERSEDED', 'RETRACTED'],
+    question: ['OPEN', 'RESOLVED', 'ANSWERED', 'DEFERRED'],
+    decision: ['PROPOSED', 'ACCEPTED', 'SUPERSEDED', 'REVERTED'],
+    episode: ['ACTIVE', 'COMPLETED'],
+};
+// ── Required Fields per Node Type ───────────────────────────────────
+export const REQUIRED_FIELDS = {
+    hypothesis: ['id', 'type', 'title', 'status', 'confidence', 'created', 'updated'],
+    experiment: ['id', 'type', 'title', 'status', 'created', 'updated'],
+    finding: ['id', 'type', 'title', 'status', 'confidence', 'created', 'updated'],
+    knowledge: ['id', 'type', 'title', 'status', 'confidence', 'created', 'updated'],
+    question: ['id', 'type', 'title', 'status', 'created', 'updated'],
+    decision: ['id', 'type', 'title', 'status', 'created', 'updated'],
+    episode: ['id', 'type', 'title', 'status', 'created', 'updated'],
+};

package/dist/graph/validator.d.ts

@@ -0,0 +1,16 @@
+import type { Node, Graph } from './types.js';
+export interface LintError {
+    nodeId: string;
+    field: string;
+    message: string;
+    severity: 'error' | 'warning';
+}
+/**
+ * Validate a single node for schema correctness.
+ * Returns an array of LintError objects.
+ */
+export declare function lintNode(node: Node): LintError[];
+/**
+ * Validate an entire graph: per-node checks + cross-node link integrity.
+ */
+export declare function lintGraph(graph: Graph): LintError[];

package/dist/graph/validator.js

@@ -0,0 +1,120 @@
+import { VALID_STATUSES, REQUIRED_FIELDS, ALL_VALID_RELATIONS } from './types.js';
+import { t } from '../i18n/index.js';
+/**
+ * Validate a single node for schema correctness.
+ * Returns an array of LintError objects.
+ */
+export function lintNode(node) {
+    const errors = [];
+    const id = node.id;
+    // Check type field
+    if (!node.type) {
+        errors.push({
+            nodeId: id,
+            field: 'type',
+            message: t('lint.missing_field', { field: 'type' }),
+            severity: 'error',
+        });
+        // Can't do type-specific checks without a type
+        return errors;
+    }
+    // Check if type is a valid NodeType
+    const validTypes = Object.keys(VALID_STATUSES);
+    if (!validTypes.includes(node.type)) {
+        errors.push({
+            nodeId: id,
+            field: 'type',
+            message: t('lint.missing_field', { field: 'type' }),
+            severity: 'error',
+        });
+        return errors;
+    }
+    const nodeType = node.type;
+    // Check title
+    if (!node.title) {
+        errors.push({
+            nodeId: id,
+            field: 'title',
+            message: t('lint.missing_field', { field: 'title' }),
+            severity: 'error',
+        });
+    }
+    // Check status
+    if (!node.status) {
+        errors.push({
+            nodeId: id,
+            field: 'status',
+            message: t('lint.missing_field', { field: 'status' }),
+            severity: 'error',
+        });
+    }
+    else {
+        const validStatuses = VALID_STATUSES[nodeType];
+        if (validStatuses && !validStatuses.includes(node.status)) {
+            errors.push({
+                nodeId: id,
+                field: 'status',
+                message: t('lint.invalid_status', {
+                    status: node.status,
+                    type: nodeType,
+                    valid: validStatuses.join(', '),
+                }),
+                severity: 'error',
+            });
+        }
+    }
+    // Check confidence range
+    if (node.confidence !== undefined) {
+        if (node.confidence < 0.0 || node.confidence > 1.0) {
+            errors.push({
+                nodeId: id,
+                field: 'confidence',
+                message: t('lint.confidence_range', { value: String(node.confidence) }),
+                severity: 'error',
+            });
+        }
+    }
+    // Check type-specific required fields: confidence for hypothesis, finding, knowledge
+    const requiredFields = REQUIRED_FIELDS[nodeType] ?? [];
+    if (requiredFields.includes('confidence') && node.confidence === undefined) {
+        errors.push({
+            nodeId: id,
+            field: 'confidence',
+            message: t('lint.missing_field', { field: 'confidence' }),
+            severity: 'warning',
+        });
+    }
+    // Check link relations
+    for (const link of node.links) {
+        if (!ALL_VALID_RELATIONS.has(link.relation)) {
+            errors.push({
+                nodeId: id,
+                field: 'links',
+                message: t('lint.invalid_relation', { relation: link.relation }),
+                severity: 'error',
+            });
+        }
+    }
+    return errors;
+}
+/**
+ * Validate an entire graph: per-node checks + cross-node link integrity.
+ */
+export function lintGraph(graph) {
+    const errors = [];
+    for (const node of graph.nodes.values()) {
+        errors.push(...lintNode(node));
+        // Check link targets exist in graph
+        for (const link of node.links) {
+            if (!graph.nodes.has(link.target)) {
+                errors.push({
+                    nodeId: node.id,
+                    field: 'links',
+                    message: t('lint.broken_link', { target: link.target }),
+                    severity: 'error',
+                });
+            }
+        }
+    }
+    return errors;
+}

package/dist/i18n/en.d.ts

@@ -0,0 +1 @@
+export declare const messages: Record<string, string>;

package/dist/i18n/en.js

@@ -0,0 +1,72 @@
+export const messages = {
+    // Health dashboard
+    'health.title': 'EMDD Health Dashboard',
+    'health.total_nodes': 'Total Nodes',
+    'health.by_type': 'By Type',
+    'health.hypothesis_status': 'Hypothesis Status',
+    'health.avg_confidence': 'Average Confidence',
+    'health.open_questions': 'Open Questions',
+    'health.orphan_findings': 'Orphan Findings',
+    'health.link_density': 'Link Density',
+    'health.recent_activity': 'Recent Activity',
+    'health.gaps': 'Structural Gaps',
+    // CLI descriptions
+    'cli.description': 'CLI for Evolving Mindmap-Driven Development',
+    'cli.init.desc': 'Initialize EMDD project',
+    'cli.new.desc': 'Create a new node',
+    'cli.health.desc': 'Show health dashboard',
+    'cli.check.desc': 'Check consolidation triggers',
+    'cli.lint.desc': 'Validate graph schema and links',
+    'cli.promote.desc': 'Identify promotion candidates',
+    'cli.index.desc': 'Generate _index.md',
+    'cli.graph.desc': 'Generate _graph.mmd',
+    'cli.update.desc': 'Update node frontmatter',
+    'cli.link.desc': 'Add a link between nodes',
+    'cli.done.desc': 'Mark episode item as done',
+    'cli.backlog.desc': 'Show backlog items',
+    // New node
+    'new.created': 'Created {type} node: {id}',
+    'new.invalid_type': 'Invalid node type: {type}. Valid types: {valid}',
+    // Init
+    'init.success': 'EMDD project initialized at {path}',
+    'init.already_exists': 'EMDD project already exists at {path}',
+    'init.next_steps': 'Next: emdd new hypothesis <slug>',
+    // Lint
+    'lint.clean': 'All nodes valid. No errors found.',
+    'lint.errors_found': '{count} error(s) found',
+    'lint.warnings_found': '{count} warning(s) found',
+    'lint.missing_field': 'Missing required field: {field}',
+    'lint.invalid_status': 'Invalid status "{status}" for type {type}. Valid: {valid}',
+    'lint.confidence_range': 'Confidence must be between 0.0 and 1.0, got {value}',
+    'lint.invalid_relation': 'Invalid link relation: {relation}',
+    'lint.broken_link': 'Link target "{target}" not found in graph',
+    // Check
+    'check.title': 'Consolidation Trigger Check',
+    'check.findings_threshold': 'Findings pending consolidation: {count} (threshold: {threshold})',
+    'check.episodes_threshold': 'Episodes since last consolidation: {count} (threshold: {threshold})',
+    'check.stale_hypothesis': 'Stale hypothesis: {id} ({days} days in {status})',
+    'check.no_triggers': 'No consolidation triggers active',
+    // Promote
+    'promote.title': 'Promotion Candidates',
+    'promote.candidate': '{id}: confidence={confidence}, supports={supports}',
+    'promote.no_candidates': 'No promotion candidates found',
+    // Update
+    'update.success': 'Updated {id}: {field} = {value}',
+    'update.node_not_found': 'Node not found: {id}',
+    // Link
+    'link.success': 'Linked {source} → {target} ({relation})',
+    'link.invalid_relation': 'Invalid relation: {relation}. Valid: {valid}',
+    // Done
+    'done.success': 'Marked as done: {item}',
+    'done.item_not_found': 'Item not found in {id}: {item}',
+    // Index
+    'index.generated': 'Generated _index.md ({nodes} nodes)',
+    // Graph
+    'graph.generated': 'Generated _graph.mmd ({nodes} nodes, {edges} edges)',
+    // Backlog
+    'backlog.title': 'Backlog Items',
+    'backlog.empty': 'No pending backlog items',
+    // Errors
+    'error.graph_not_found': 'No graph/ directory found',
+    'error.node_not_found': 'Node not found: {id}',
+};

package/dist/i18n/index.d.ts

@@ -0,0 +1,4 @@
+export type Locale = 'en' | 'ko';
+export declare function getLocale(override?: string): Locale;
+export declare function setLocale(locale: Locale): void;
+export declare function t(key: string, vars?: Record<string, string>): string;

package/dist/i18n/index.js

@@ -0,0 +1,26 @@
+import { messages as en } from './en.js';
+import { messages as ko } from './ko.js';
+const MESSAGES = { en, ko };
+const VALID_LOCALES = new Set(['en', 'ko']);
+let currentLocale = 'en';
+export function getLocale(override) {
+    if (override && VALID_LOCALES.has(override))
+        return override;
+    if (override)
+        return 'en'; // invalid locale -> fallback
+    const env = process.env.EMDD_LANG;
+    if (env && VALID_LOCALES.has(env))
+        return env;
+    return 'en';
+}
+export function setLocale(locale) {
+    currentLocale = locale;
+}
+export function t(key, vars) {
+    const msg = MESSAGES[currentLocale]?.[key];
+    if (!msg)
+        return key; // fallback: return key itself
+    if (!vars)
+        return msg;
+    return msg.replace(/\{(\w+)\}/g, (_, name) => vars[name] ?? `{${name}}`);
+}

package/dist/i18n/ko.d.ts

@@ -0,0 +1 @@
+export declare const messages: Record<string, string>;

package/dist/i18n/ko.js

@@ -0,0 +1,72 @@
+export const messages = {
+    // 건강 대시보드
+    'health.title': 'EMDD 건강 대시보드',
+    'health.total_nodes': '전체 노드 수',
+    'health.by_type': '타입별 분포',
+    'health.hypothesis_status': '가설 상태',
+    'health.avg_confidence': '평균 신뢰도',
+    'health.open_questions': '미해결 질문',
+    'health.orphan_findings': '고아 발견사항',
+    'health.link_density': '링크 밀도',
+    'health.recent_activity': '최근 활동',
+    'health.gaps': '구조적 공백',
+    // CLI 설명
+    'cli.description': '진화하는 마인드맵 주도 개발을 위한 CLI',
+    'cli.init.desc': 'EMDD 프로젝트 초기화',
+    'cli.new.desc': '새 노드 생성',
+    'cli.health.desc': '건강 대시보드 표시',
+    'cli.check.desc': '통합 트리거 확인',
+    'cli.lint.desc': '그래프 스키마 및 링크 검증',
+    'cli.promote.desc': '승격 후보 식별',
+    'cli.index.desc': '_index.md 생성',
+    'cli.graph.desc': '_graph.mmd 생성',
+    'cli.update.desc': '노드 프론트매터 업데이트',
+    'cli.link.desc': '노드 간 링크 추가',
+    'cli.done.desc': '에피소드 항목 완료 표시',
+    'cli.backlog.desc': '백로그 항목 표시',
+    // 새 노드
+    'new.created': '{type} 노드 생성됨: {id}',
+    'new.invalid_type': '잘못된 노드 타입: {type}. 유효한 타입: {valid}',
+    // 초기화
+    'init.success': '{path}에 EMDD 프로젝트가 초기화되었습니다',
+    'init.already_exists': '{path}에 EMDD 프로젝트가 이미 존재합니다',
+    'init.next_steps': '다음: emdd new hypothesis <slug>',
+    // 린트
+    'lint.clean': '모든 노드가 유효합니다. 오류가 없습니다.',
+    'lint.errors_found': '{count}개 오류 발견',
+    'lint.warnings_found': '{count}개 경고 발견',
+    'lint.missing_field': '필수 필드 누락: {field}',
+    'lint.invalid_status': '타입 {type}에 대한 잘못된 상태 "{status}". 유효한 값: {valid}',
+    'lint.confidence_range': '신뢰도는 0.0에서 1.0 사이여야 합니다. 입력값: {value}',
+    'lint.invalid_relation': '잘못된 링크 관계: {relation}',
+    'lint.broken_link': '링크 대상 "{target}"을(를) 그래프에서 찾을 수 없습니다',
+    // 통합 확인
+    'check.title': '통합 트리거 확인',
+    'check.findings_threshold': '통합 대기 중인 발견사항: {count}개 (임계값: {threshold})',
+    'check.episodes_threshold': '마지막 통합 이후 에피소드: {count}개 (임계값: {threshold})',
+    'check.stale_hypothesis': '오래된 가설: {id} ({status} 상태로 {days}일)',
+    'check.no_triggers': '활성화된 통합 트리거 없음',
+    // 승격
+    'promote.title': '승격 후보',
+    'promote.candidate': '{id}: 신뢰도={confidence}, 지지={supports}',
+    'promote.no_candidates': '승격 후보가 없습니다',
+    // 업데이트
+    'update.success': '{id} 업데이트됨: {field} = {value}',
+    'update.node_not_found': '노드를 찾을 수 없습니다: {id}',
+    // 링크
+    'link.success': '{source} → {target} 연결됨 ({relation})',
+    'link.invalid_relation': '잘못된 관계: {relation}. 유효한 값: {valid}',
+    // 완료
+    'done.success': '완료 표시됨: {item}',
+    'done.item_not_found': '{id}에서 항목을 찾을 수 없습니다: {item}',
+    // 인덱스
+    'index.generated': '_index.md 생성됨 ({nodes}개 노드)',
+    // 그래프
+    'graph.generated': '_graph.mmd 생성됨 ({nodes}개 노드, {edges}개 엣지)',
+    // 백로그
+    'backlog.title': '백로그 항목',
+    'backlog.empty': '대기 중인 백로그 항목 없음',
+    // 오류
+    'error.graph_not_found': 'graph/ 디렉토리를 찾을 수 없습니다',
+    'error.node_not_found': '노드를 찾을 수 없습니다: {id}',
+};

package/dist/mcp-server/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/mcp-server/cli.js

@@ -0,0 +1,6 @@
+#!/usr/bin/env node
+import { startMcpServer } from './index.js';
+startMcpServer().catch((err) => {
+    console.error('Failed to start EMDD MCP server:', err);
+    process.exit(1);
+});

package/dist/mcp-server/index.d.ts

@@ -0,0 +1,3 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+export declare function createEmddMcpServer(): McpServer;
+export declare function startMcpServer(): Promise<void>;

package/dist/mcp-server/index.js

@@ -0,0 +1,35 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { registerListNodes } from './tools/list-nodes.js';
+import { registerReadNode } from './tools/read-node.js';
+import { registerCreateNode } from './tools/create-node.js';
+import { registerCreateEdge } from './tools/create-edge.js';
+import { registerHealth } from './tools/health.js';
+import { registerCheck } from './tools/check.js';
+import { registerPromote } from './tools/promote.js';
+import { registerContextLoading } from './prompts/context-loading.js';
+import { registerEpisodeCreation } from './prompts/episode-creation.js';
+import { registerConsolidation } from './prompts/consolidation.js';
+import { registerHealthReview } from './prompts/health-review.js';
+export function createEmddMcpServer() {
+    const server = new McpServer({ name: 'emdd', version: '0.1.0' });
+    // Tools
+    registerListNodes(server);
+    registerReadNode(server);
+    registerCreateNode(server);
+    registerCreateEdge(server);
+    registerHealth(server);
+    registerCheck(server);
+    registerPromote(server);
+    // Prompts
+    registerContextLoading(server);
+    registerEpisodeCreation(server);
+    registerConsolidation(server);
+    registerHealthReview(server);
+    return server;
+}
+export async function startMcpServer() {
+    const server = createEmddMcpServer();
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+}

package/dist/mcp-server/prompts/consolidation.d.ts

@@ -0,0 +1,2 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+export declare function registerConsolidation(server: McpServer): void;

package/dist/mcp-server/prompts/consolidation.js

@@ -0,0 +1,64 @@
+import { z } from 'zod';
+import { checkConsolidation, getHealth } from '../../graph/operations.js';
+export function registerConsolidation(server) {
+    server.prompt('consolidation', 'Consolidation execution guide — checks triggers and provides a step-by-step procedure for promoting findings, generating questions, and updating hypotheses', { path: z.string().describe('Path to the EMDD graph directory') }, async ({ path: graphDir }) => {
+        const checkResult = await checkConsolidation(graphDir);
+        const health = await getHealth(graphDir);
+        const triggersSection = checkResult.triggers.length > 0
+            ? checkResult.triggers.map(t => `  - [TRIGGERED] ${t.message}`).join('\n')
+            : '  No triggers active — consolidation is optional but you may still run it proactively.';
+        const text = `# EMDD Consolidation Guide
+
+## Current Trigger Status
+${triggersSection}
+
+## Graph State
+- Total nodes: ${health.totalNodes}
+- Total edges: ${health.totalEdges}
+- Open questions: ${health.openQuestions}
+- Average confidence: ${health.avgConfidence !== null ? health.avgConfidence.toFixed(2) : 'N/A'}
+
+## Consolidation Triggers (run if any apply)
+- 5 or more Finding nodes added since last Consolidation
+- 3 or more Episode nodes added since last Consolidation
+- 0 open Questions (the illusion that research is "done")
+- An Experiment has become a catch-all with 5+ Findings attached
+
+## Step-by-Step Consolidation Procedure
+
+### Step 1: Promotion
+Review all Finding nodes. For each Finding with high confidence (>= 0.8) and strong evidence (2+ supporting links):
+- Promote it to a Knowledge node using the \`create-node\` tool (type: knowledge).
+- Add a \`promotes\` edge from the new Knowledge node to the original Finding.
+- Use the \`promote\` tool to identify candidates automatically.
+
+### Step 2: Splitting
+Review Experiments with many attached Findings (5+):
+- Split bloated Experiments into focused sub-experiments.
+- Reassign Findings to the appropriate sub-experiment.
+
+### Step 3: Question Generation
+Review Episode "Questions That Arose" sections:
+- Convert unrecorded questions into Question nodes using \`create-node\` (type: question).
+- Link new Questions to their source Episodes with \`spawns\`.
+
+### Step 4: Hypothesis Update
+Review all active Hypotheses:
+- Update confidence values based on new Finding evidence.
+- Create new Hypotheses if patterns suggest unexplored directions.
+- Check kill criteria — mark REFUTED if a kill criterion is met.
+
+### Step 5: Orphan Cleanup
+Find Findings without outgoing links:
+- Add \`supports\`, \`contradicts\`, or \`spawns\` edges as appropriate.
+- Every Finding should connect to at least one Hypothesis or Question.
+
+## Consolidation Principles
+- Consolidation is an obligation, not optional — check triggers after creating Episodes or Findings.
+- Do not record Consolidation itself as an Episode — it is a meta-activity.
+- Do not start new exploration during Consolidation — this is garden tending, not planting.`;
+        return {
+            messages: [{ role: 'user', content: { type: 'text', text } }],
+        };
+    });
+}

package/dist/mcp-server/prompts/context-loading.d.ts

@@ -0,0 +1,2 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+export declare function registerContextLoading(server: McpServer): void;

package/dist/mcp-server/prompts/context-loading.js

@@ -0,0 +1,52 @@
+import { z } from 'zod';
+import { getHealth } from '../../graph/operations.js';
+import { listNodes } from '../../graph/operations.js';
+export function registerContextLoading(server) {
+    server.prompt('context-loading', 'Load EMDD graph context for session start — provides a summary of nodes, edges, health, and structural gaps', { path: z.string().describe('Path to the EMDD graph directory') }, async ({ path: graphDir }) => {
+        const health = await getHealth(graphDir);
+        const nodes = await listNodes(graphDir);
+        const typeBreakdown = Object.entries(health.byType)
+            .filter(([, count]) => count > 0)
+            .map(([type, count]) => `  - ${type}: ${count}`)
+            .join('\n');
+        const gapsSection = health.gaps.length > 0
+            ? health.gaps.map(g => `  - ${g}`).join('\n')
+            : '  None detected';
+        const confidenceInfo = health.avgConfidence !== null
+            ? `Average confidence: ${health.avgConfidence.toFixed(2)}`
+            : 'Average confidence: N/A (no confidence values)';
+        const recentNodes = nodes
+            .slice(0, 10)
+            .map(n => `  - [${n.id}] ${n.title} (${n.type}, ${n.status ?? 'no status'})`)
+            .join('\n');
+        const text = `# EMDD Graph Context — Session Start
+
+## Graph Overview
+- Total nodes: ${health.totalNodes}
+- Total edges: ${health.totalEdges}
+- Link density: ${health.linkDensity.toFixed(2)} edges/node
+- ${confidenceInfo}
+- Open questions: ${health.openQuestions}
+
+## Node Counts by Type
+${typeBreakdown}
+
+## Structural Gaps
+${gapsSection}
+
+## Recent Nodes (up to 10)
+${recentNodes}
+
+## Session Start Instructions
+1. Review the graph overview above to understand the current state.
+2. Check structural gaps — these indicate missing connections in the research loop.
+3. Read the latest Episode node's "What's Next" section for planned work.
+4. Load prerequisite reading nodes listed in that Episode before starting.
+5. Decide today's direction based on graph state and open questions.
+
+Use the \`list-nodes\` and \`read-node\` tools to explore specific nodes in detail.`;
+        return {
+            messages: [{ role: 'user', content: { type: 'text', text } }],
+        };
+    });
+}

package/dist/mcp-server/prompts/episode-creation.d.ts

@@ -0,0 +1,2 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+export declare function registerEpisodeCreation(server: McpServer): void;