Migrate all repos into monorepo context folders

Bahn: aisupport, Analyse-O2C-C2S, awesome-bahn-mcp-servers, beam-mcp,
      Confluence_Bot, db-planet-mcp-server, O2C-Harness, project-audit,
      Projekt-KIQ-HP, teamlandkarte-mcp
Dhive: Jury-Voting
Privat: CV, NoteGraph (NOTE: NoteGraph needs complete redo after consolidation)
Shared: AI-Orchestrator, OrgMyLife, power_skills_and_more
Shared/references: symphony (read-only)

Bahn repos remain available as independent remotes - this monorepo
pulls them in via subtree, the originals are untouched.

privat/CV/src/cv/cv.test.ts

@@ -0,0 +1,338 @@
+import { describe, it, expect } from 'vitest';
+import fc from 'fast-check';
+import { selectRelevant } from './relevance-selection';
+import { generateTandemData } from './tandem-generator';
+import type { Experience, Skill, Project, Person, Tandem } from '../schemas/types';
+
+// --- Arbitraries ---
+
+const kebabCaseId = fc
+  .array(
+    fc.stringMatching(/^[a-z0-9]{1,8}$/),
+    { minLength: 1, maxLength: 4 }
+  )
+  .map(parts => parts.join('-'));
+
+const isoDate = fc
+  .record({
+    year: fc.integer({ min: 1990, max: 2030 }),
+    month: fc.integer({ min: 1, max: 12 }),
+  })
+  .map(({ year, month }) => `${year}-${String(month).padStart(2, '0')}`);
+
+const skillCategory = fc.constantFrom(
+  'programming-language' as const,
+  'framework' as const,
+  'methodology' as const,
+  'soft-skill' as const,
+  'domain' as const
+);
+
+const skillLevel = fc.constantFrom(
+  'beginner' as const,
+  'intermediate' as const,
+  'advanced' as const,
+  'expert' as const
+);
+
+/** Generates a Skill entity */
+const skillArb = fc.record({
+  id: kebabCaseId,
+  created: isoDate,
+  modified: isoDate,
+  name: fc.string({ minLength: 1, maxLength: 20 }).filter(s => s.trim().length > 0),
+  category: skillCategory,
+  level: skillLevel,
+}).map(f => ({
+  id: f.id,
+  type: 'skill' as const,
+  created: f.created,
+  modified: f.modified,
+  name: f.name,
+  category: f.category,
+  level: f.level,
+}));
+
+/** Generates an Experience entity */
+const experienceArb = fc.record({
+  id: kebabCaseId,
+  created: isoDate,
+  modified: isoDate,
+  title: fc.string({ minLength: 1, maxLength: 30 }).filter(s => s.trim().length > 0),
+  organization: kebabCaseId,
+  start: isoDate,
+  description: fc.string({ minLength: 0, maxLength: 50 }),
+  skillsUsed: fc.array(fc.string({ minLength: 1, maxLength: 15 }).filter(s => s.trim().length > 0), { minLength: 0, maxLength: 5 }),
+}).map(f => ({
+  id: f.id,
+  type: 'experience' as const,
+  created: f.created,
+  modified: f.modified,
+  title: f.title,
+  organization: f.organization,
+  start: f.start,
+  end: null,
+  description: f.description,
+  skillsUsed: f.skillsUsed,
+}));
+
+/** Generates a Project entity */
+const projectArb = fc.record({
+  id: kebabCaseId,
+  created: isoDate,
+  modified: isoDate,
+  name: fc.string({ minLength: 1, maxLength: 30 }).filter(s => s.trim().length > 0),
+  organization: kebabCaseId,
+  start: isoDate,
+  description: fc.string({ minLength: 0, maxLength: 50 }),
+  skillsUsed: fc.array(fc.string({ minLength: 1, maxLength: 15 }).filter(s => s.trim().length > 0), { minLength: 0, maxLength: 5 }),
+}).map(f => ({
+  id: f.id,
+  type: 'project' as const,
+  created: f.created,
+  modified: f.modified,
+  name: f.name,
+  organization: f.organization,
+  start: f.start,
+  description: f.description,
+  skillsUsed: f.skillsUsed,
+}));
+
+/** Generates a Person entity */
+const personArb = fc.record({
+  id: kebabCaseId,
+  created: isoDate,
+  modified: isoDate,
+  firstName: fc.string({ minLength: 1, maxLength: 15 }).filter(s => s.trim().length > 0),
+  lastName: fc.string({ minLength: 1, maxLength: 15 }).filter(s => s.trim().length > 0),
+  summary: fc.string({ minLength: 0, maxLength: 50 }),
+}).map(f => ({
+  id: f.id,
+  type: 'person' as const,
+  created: f.created,
+  modified: f.modified,
+  name: { first: f.firstName, last: f.lastName, display: `${f.firstName} ${f.lastName}` },
+  summary: f.summary || undefined,
+  skills: [] as string[],
+  experiences: [] as string[],
+}));
+
+/** Generates a Tandem entity referencing two partner IDs */
+const tandemArb = (partner1Id: string, partner2Id: string) => fc.record({
+  id: kebabCaseId,
+  created: isoDate,
+  modified: isoDate,
+  sharedVision: fc.string({ minLength: 1, maxLength: 50 }).filter(s => s.trim().length > 0),
+  complementarySkills: fc.string({ minLength: 1, maxLength: 50 }).filter(s => s.trim().length > 0),
+  collaborationModel: fc.string({ minLength: 1, maxLength: 50 }).filter(s => s.trim().length > 0),
+  combinedNarrative: fc.string({ minLength: 0, maxLength: 50 }),
+  jointCompetencies: fc.array(fc.string({ minLength: 1, maxLength: 20 }).filter(s => s.trim().length > 0), { minLength: 0, maxLength: 3 }),
+}).map(f => ({
+  id: f.id,
+  type: 'tandem' as const,
+  created: f.created,
+  modified: f.modified,
+  partners: [partner1Id, partner2Id] as [string, string],
+  sharedVision: f.sharedVision,
+  complementarySkills: f.complementarySkills,
+  collaborationModel: f.collaborationModel,
+  combinedNarrative: f.combinedNarrative || undefined,
+  jointCompetencies: f.jointCompetencies.length > 0 ? f.jointCompetencies : undefined,
+}));
+
+// --- Property 9: CV relevance selection ordering ---
+
+describe('Property 9: CV relevance selection ordering', () => {
+  it('matching items have score > 0 and appear before score-0 items in the output', () => {
+    fc.assert(
+      fc.property(
+        fc.array(fc.string({ minLength: 1, maxLength: 15 }).filter(s => s.trim().length > 0), { minLength: 1, maxLength: 5 }),
+        fc.array(experienceArb, { minLength: 0, maxLength: 5 }),
+        fc.array(skillArb, { minLength: 0, maxLength: 5 }),
+        fc.array(projectArb, { minLength: 0, maxLength: 5 }),
+        (requirements, experiences, skills, projects) => {
+          const results = selectRelevant(requirements, experiences, skills, projects);
+
+          // All items with matchedRequirements.length > 0 must have score > 0
+          for (const r of results) {
+            if (r.matchedRequirements.length > 0) {
+              expect(r.score).toBeGreaterThan(0);
+            }
+          }
+
+          // Items are sorted: all score > 0 items appear before score === 0 items
+          let seenZero = false;
+          for (const r of results) {
+            if (r.score === 0) {
+              seenZero = true;
+            } else if (seenZero) {
+              // A non-zero score item appeared after a zero-score item — ordering violated
+              expect(seenZero && r.score > 0).toBe(false);
+            }
+          }
+
+          // Results are sorted by score descending
+          for (let i = 1; i < results.length; i++) {
+            expect(results[i - 1].score).toBeGreaterThanOrEqual(results[i].score);
+          }
+        }
+      ),
+      { numRuns: 100 }
+    );
+  });
+
+  /**
+   * Validates: Requirements 5.1, 5.2
+   */
+});
+
+// --- Property 10: Tandem application document set (exactly 3 docs) ---
+
+describe('Property 10: Tandem application document set', () => {
+  it('generateTandemData produces data with exactly 2 partner profiles referencing both partners', () => {
+    fc.assert(
+      fc.property(
+        personArb,
+        personArb,
+        fc.array(experienceArb, { minLength: 0, maxLength: 3 }),
+        fc.array(experienceArb, { minLength: 0, maxLength: 3 }),
+        fc.array(skillArb, { minLength: 0, maxLength: 3 }),
+        fc.array(skillArb, { minLength: 0, maxLength: 3 }),
+        (partner1, partner2, exp1, exp2, skills1, skills2) => {
+          // Ensure distinct partner IDs
+          const p1 = { ...partner1, id: partner1.id + '-p1' };
+          const p2 = { ...partner2, id: partner2.id + '-p2' };
+
+          const tandem: Tandem = {
+            id: 'tandem-test',
+            type: 'tandem',
+            created: '2025-01-01',
+            modified: '2025-01-01',
+            partners: [p1.id, p2.id],
+            sharedVision: 'Shared vision text',
+            complementarySkills: 'Complementary skills text',
+            collaborationModel: 'Collaboration model text',
+          };
+
+          const result = generateTandemData(
+            tandem,
+            p1 as Person,
+            p2 as Person,
+            exp1,
+            exp2,
+            skills1,
+            skills2
+          );
+
+          // Exactly 2 partner profiles in the output
+          expect(result.partnerProfiles).toHaveLength(2);
+
+          // The tandem CV references both partners
+          expect(result.partners).toContain(p1.id);
+          expect(result.partners).toContain(p2.id);
+
+          // Each partner profile corresponds to one of the partners
+          const profileIds = result.partnerProfiles.map(p => p.personId);
+          expect(profileIds).toContain(p1.id);
+          expect(profileIds).toContain(p2.id);
+
+          // The tandem data contains shared information from both profiles
+          expect(result.sharedVision).toBeTruthy();
+          expect(result.complementarySkills).toBeTruthy();
+          expect(result.collaborationModel).toBeTruthy();
+        }
+      ),
+      { numRuns: 100 }
+    );
+  });
+
+  /**
+   * Validates: Requirements 5.3, 5.4
+   */
+});
+
+// --- Property 11: CV output validity and traceability ---
+
+describe('Property 11: CV output validity and traceability', () => {
+  it('all data in TandemDocumentData traces back to input entities', () => {
+    fc.assert(
+      fc.property(
+        personArb,
+        personArb,
+        fc.array(experienceArb, { minLength: 1, maxLength: 4 }),
+        fc.array(experienceArb, { minLength: 1, maxLength: 4 }),
+        fc.array(skillArb, { minLength: 1, maxLength: 4 }),
+        fc.array(skillArb, { minLength: 1, maxLength: 4 }),
+        (partner1, partner2, exp1, exp2, skills1, skills2) => {
+          const p1 = { ...partner1, id: partner1.id + '-p1' };
+          const p2 = { ...partner2, id: partner2.id + '-p2' };
+
+          const tandem: Tandem = {
+            id: 'tandem-trace',
+            type: 'tandem',
+            created: '2025-01-01',
+            modified: '2025-01-01',
+            partners: [p1.id, p2.id],
+            sharedVision: 'Vision',
+            complementarySkills: 'Skills complement',
+            collaborationModel: 'Model',
+            combinedNarrative: 'Narrative',
+            jointCompetencies: ['competency-1', 'competency-2'],
+          };
+
+          const result = generateTandemData(
+            tandem,
+            p1 as Person,
+            p2 as Person,
+            exp1,
+            exp2,
+            skills1,
+            skills2
+          );
+
+          // All skill names in partner profiles must come from input skills
+          const allInputSkillNames = [...skills1, ...skills2].map(s => s.name);
+          for (const profile of result.partnerProfiles) {
+            for (const skillName of profile.topSkills) {
+              expect(allInputSkillNames).toContain(skillName);
+            }
+          }
+
+          // All experience titles in partner profiles must come from input experiences
+          const allInputExpTitles = [...exp1, ...exp2].map(e => e.title);
+          for (const profile of result.partnerProfiles) {
+            for (const exp of profile.topExperiences) {
+              expect(allInputExpTitles).toContain(exp.title);
+            }
+          }
+
+          // All organization references in experiences must come from input experiences
+          const allInputOrgs = [...exp1, ...exp2].map(e => e.organization);
+          for (const profile of result.partnerProfiles) {
+            for (const exp of profile.topExperiences) {
+              expect(allInputOrgs).toContain(exp.organization);
+            }
+          }
+
+          // Display names must come from input persons
+          const inputDisplayNames = [p1.name.display, p2.name.display];
+          for (const profile of result.partnerProfiles) {
+            expect(inputDisplayNames).toContain(profile.displayName);
+          }
+
+          // Tandem-level data must trace back to the tandem entity
+          expect(result.sharedVision).toBe(tandem.sharedVision);
+          expect(result.complementarySkills).toBe(tandem.complementarySkills);
+          expect(result.collaborationModel).toBe(tandem.collaborationModel);
+          expect(result.combinedNarrative).toBe(tandem.combinedNarrative);
+          expect(result.jointCompetencies).toEqual(tandem.jointCompetencies);
+        }
+      ),
+      { numRuns: 100 }
+    );
+  });
+
+  /**
+   * Validates: Requirements 5.5, 5.6
+   */
+});

privat/CV/src/cv/relevance-selection.ts

@@ -0,0 +1,78 @@
+import type { Experience, Skill, Project } from '../schemas/types';
+
+export interface RelevanceResult {
+  entityId: string;
+  entityType: 'experience' | 'skill' | 'project';
+  score: number;
+  matchedRequirements: string[];
+}
+
+/**
+ * Scores and ranks experiences, skills, and projects by relevance to job posting requirements.
+ * Items with matches appear before non-matching items, sorted by score descending.
+ */
+export function selectRelevant(
+  requirements: string[],
+  experiences: Experience[],
+  skills: Skill[],
+  projects: Project[]
+): RelevanceResult[] {
+  const lowerReqs = requirements.map(r => r.toLowerCase());
+
+  const results: RelevanceResult[] = [];
+
+  for (const skill of skills) {
+    const matched = lowerReqs.filter(req => skill.name.toLowerCase().includes(req) || req.includes(skill.name.toLowerCase()));
+    results.push({
+      entityId: skill.id,
+      entityType: 'skill',
+      score: matched.length,
+      matchedRequirements: matched,
+    });
+  }
+
+  for (const exp of experiences) {
+    const matched = findMatchingRequirements(lowerReqs, exp.skillsUsed, exp.title, exp.description);
+    results.push({
+      entityId: exp.id,
+      entityType: 'experience',
+      score: matched.length,
+      matchedRequirements: matched,
+    });
+  }
+
+  for (const project of projects) {
+    const matched = findMatchingRequirements(lowerReqs, project.skillsUsed, project.name, project.description);
+    results.push({
+      entityId: project.id,
+      entityType: 'project',
+      score: matched.length,
+      matchedRequirements: matched,
+    });
+  }
+
+  results.sort((a, b) => b.score - a.score);
+  return results;
+}
+
+function findMatchingRequirements(
+  lowerReqs: string[],
+  skillsUsed: string[] | undefined,
+  title: string,
+  description: string | undefined
+): string[] {
+  const matched = new Set<string>();
+  const lowerTitle = title.toLowerCase();
+  const lowerDesc = (description ?? '').toLowerCase();
+  const lowerSkills = (skillsUsed ?? []).map(s => s.toLowerCase());
+
+  for (const req of lowerReqs) {
+    if (lowerSkills.some(s => s.includes(req) || req.includes(s))) {
+      matched.add(req);
+    } else if (lowerTitle.includes(req) || lowerDesc.includes(req)) {
+      matched.add(req);
+    }
+  }
+
+  return [...matched];
+}

privat/CV/src/cv/tandem-generator.ts

@@ -0,0 +1,67 @@
+import type { Tandem, Person, Experience, Skill } from '../schemas/types';
+
+export interface PartnerProfile {
+  personId: string;
+  displayName: string;
+  summary?: string;
+  topSkills: string[];
+  topExperiences: Array<{ title: string; organization: string; start: string; end: string | null }>;
+}
+
+export interface TandemDocumentData {
+  tandemId: string;
+  partners: [string, string];
+  sharedVision: string;
+  complementarySkills: string;
+  collaborationModel: string;
+  combinedNarrative?: string;
+  jointCompetencies?: string[];
+  partnerProfiles: PartnerProfile[];
+}
+
+/**
+ * Produces a structured tandem document from a tandem entity and both partners' data.
+ * Returns data only — formatting is handled by templates.
+ */
+export function generateTandemData(
+  tandem: Tandem,
+  partner1Profile: Person,
+  partner2Profile: Person,
+  partner1Experiences: Experience[],
+  partner2Experiences: Experience[],
+  partner1Skills: Skill[],
+  partner2Skills: Skill[]
+): TandemDocumentData {
+  return {
+    tandemId: tandem.id,
+    partners: tandem.partners,
+    sharedVision: tandem.sharedVision,
+    complementarySkills: tandem.complementarySkills,
+    collaborationModel: tandem.collaborationModel,
+    combinedNarrative: tandem.combinedNarrative,
+    jointCompetencies: tandem.jointCompetencies,
+    partnerProfiles: [
+      buildPartnerProfile(partner1Profile, partner1Experiences, partner1Skills),
+      buildPartnerProfile(partner2Profile, partner2Experiences, partner2Skills),
+    ],
+  };
+}
+
+function buildPartnerProfile(
+  person: Person,
+  experiences: Experience[],
+  skills: Skill[]
+): PartnerProfile {
+  return {
+    personId: person.id,
+    displayName: person.name.display,
+    summary: person.summary,
+    topSkills: skills.map(s => s.name),
+    topExperiences: experiences.map(exp => ({
+      title: exp.title,
+      organization: exp.organization,
+      start: exp.start,
+      end: exp.end,
+    })),
+  };
+}

privat/CV/src/graph/index-manager.test.ts

@@ -0,0 +1,825 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { mkdtemp, rm, readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import {
+  readGraphIndex,
+  writeGraphIndex,
+  addEntity,
+  removeEntity,
+  addRelationship,
+  removeRelationship,
+  validateRelationshipType,
+  getGraphIndexPath,
+  rebuildGraphIndex,
+} from './index-manager';
+import { writeEntity } from '../io/entity-files';
+
+describe('index-manager', () => {
+  let tempDir: string;
+
+  beforeEach(async () => {
+    tempDir = await mkdtemp(join(tmpdir(), 'graph-index-test-'));
+  });
+
+  afterEach(async () => {
+    await rm(tempDir, { recursive: true, force: true });
+  });
+
+  describe('readGraphIndex', () => {
+    it('returns empty index when file does not exist', async () => {
+      const index = await readGraphIndex(tempDir);
+      expect(index).toEqual({ entities: [], relationships: [] });
+    });
+  });
+
+  describe('writeGraphIndex / readGraphIndex round-trip', () => {
+    it('writes and reads back the same index', async () => {
+      const index = {
+        entities: [{ id: 'andre-knie', type: 'person' as const, name: 'Andre Knie' }],
+        relationships: [{ from: 'andre-knie', to: 'python', type: 'has_skill' as const }],
+      };
+      await writeGraphIndex(index, tempDir);
+      const result = await readGraphIndex(tempDir);
+      expect(result).toEqual(index);
+    });
+  });
+
+  describe('addEntity', () => {
+    it('adds a new entity to an empty index', async () => {
+      await addEntity({ id: 'python', type: 'skill', name: 'Python' }, tempDir);
+      const index = await readGraphIndex(tempDir);
+      expect(index.entities).toHaveLength(1);
+      expect(index.entities[0]).toEqual({ id: 'python', type: 'skill', name: 'Python' });
+    });
+
+    it('replaces an existing entity with the same ID', async () => {
+      await addEntity({ id: 'python', type: 'skill', name: 'Python' }, tempDir);
+      await addEntity({ id: 'python', type: 'skill', name: 'Python 3' }, tempDir);
+      const index = await readGraphIndex(tempDir);
+      expect(index.entities).toHaveLength(1);
+      expect(index.entities[0].name).toBe('Python 3');
+    });
+  });
+
+  describe('removeEntity', () => {
+    it('removes an entity and its relationships', async () => {
+      await writeGraphIndex(
+        {
+          entities: [
+            { id: 'andre-knie', type: 'person', name: 'Andre Knie' },
+            { id: 'python', type: 'skill', name: 'Python' },
+          ],
+          relationships: [
+            { from: 'andre-knie', to: 'python', type: 'has_skill' },
+          ],
+        },
+        tempDir
+      );
+      await removeEntity('python', tempDir);
+      const index = await readGraphIndex(tempDir);
+      expect(index.entities).toHaveLength(1);
+      expect(index.entities[0].id).toBe('andre-knie');
+      expect(index.relationships).toHaveLength(0);
+    });
+  });
+
+  describe('addRelationship', () => {
+    it('adds a valid relationship', async () => {
+      await addRelationship({ from: 'andre-knie', to: 'db-cargo', type: 'worked_at' }, tempDir);
+      const index = await readGraphIndex(tempDir);
+      expect(index.relationships).toHaveLength(1);
+      expect(index.relationships[0]).toEqual({ from: 'andre-knie', to: 'db-cargo', type: 'worked_at' });
+    });
+
+    it('does not duplicate identical relationships', async () => {
+      await addRelationship({ from: 'andre-knie', to: 'db-cargo', type: 'worked_at' }, tempDir);
+      await addRelationship({ from: 'andre-knie', to: 'db-cargo', type: 'worked_at' }, tempDir);
+      const index = await readGraphIndex(tempDir);
+      expect(index.relationships).toHaveLength(1);
+    });
+
+    it('rejects invalid relationship types', async () => {
+      await expect(
+        addRelationship({ from: 'a', to: 'b', type: 'invalid_type' as any }, tempDir)
+      ).rejects.toThrow('Invalid relationship type');
+    });
+  });
+
+  describe('removeRelationship', () => {
+    it('removes a matching relationship', async () => {
+      await writeGraphIndex(
+        {
+          entities: [],
+          relationships: [
+            { from: 'andre-knie', to: 'python', type: 'has_skill' },
+            { from: 'andre-knie', to: 'db-cargo', type: 'worked_at' },
+          ],
+        },
+        tempDir
+      );
+      await removeRelationship('andre-knie', 'python', 'has_skill', tempDir);
+      const index = await readGraphIndex(tempDir);
+      expect(index.relationships).toHaveLength(1);
+      expect(index.relationships[0].type).toBe('worked_at');
+    });
+  });
+
+  describe('validateRelationshipType', () => {
+    it('accepts all valid types', () => {
+      const validTypes = ['has_skill', 'worked_at', 'collaborated_with', 'applied_for', 'partners_with'];
+      for (const t of validTypes) {
+        expect(() => validateRelationshipType(t)).not.toThrow();
+      }
+    });
+
+    it('rejects invalid types', () => {
+      expect(() => validateRelationshipType('likes')).toThrow('Invalid relationship type');
+    });
+  });
+
+  describe('getGraphIndexPath', () => {
+    it('returns correct path relative to basePath', () => {
+      const path = getGraphIndexPath('/my/project');
+      expect(path).toBe(join('/my/project', 'kb', 'graph-index.yaml'));
+    });
+  });
+});
+
+describe('rebuildGraphIndex', () => {
+  let tempDir: string;
+
+  beforeEach(async () => {
+    tempDir = await mkdtemp(join(tmpdir(), 'rebuild-test-'));
+  });
+
+  afterEach(async () => {
+    await rm(tempDir, { recursive: true, force: true });
+  });
+
+  it('returns empty index when no entities exist', async () => {
+    const result = await rebuildGraphIndex(tempDir);
+    expect(result.index.entities).toEqual([]);
+    expect(result.index.relationships).toEqual([]);
+    expect(result.warnings).toEqual([]);
+  });
+
+  it('builds entities list from entity files', async () => {
+    await writeEntity(
+      {
+        id: 'python',
+        type: 'skill',
+        created: '2025-01-15',
+        modified: '2025-01-15',
+        name: 'Python',
+        category: 'programming-language',
+        level: 'expert',
+      },
+      tempDir
+    );
+    await writeEntity(
+      {
+        id: 'db-cargo',
+        type: 'organization',
+        created: '2025-01-15',
+        modified: '2025-01-15',
+        name: 'DB Cargo AG',
+        industry: 'logistics',
+      },
+      tempDir
+    );
+
+    const result = await rebuildGraphIndex(tempDir);
+    expect(result.index.entities).toHaveLength(2);
+    const ids = result.index.entities.map((e) => e.id).sort();
+    expect(ids).toEqual(['db-cargo', 'python']);
+  });
+
+  it('infers has_skill relationships from person skills', async () => {
+    await writeEntity(
+      {
+        id: 'python',
+        type: 'skill',
+        created: '2025-01-15',
+        modified: '2025-01-15',
+        name: 'Python',
+        category: 'programming-language',
+        level: 'expert',
+      },
+      tempDir
+    );
+    await writeEntity(
+      {
+        id: 'andre-knie',
+        type: 'person',
+        created: '2025-01-15',
+        modified: '2025-01-15',
+        name: { first: 'Andre', last: 'Knie', display: 'Andre Knie' },
+        skills: ['python'],
+      },
+      tempDir
+    );
+
+    const result = await rebuildGraphIndex(tempDir);
+    expect(result.index.relationships).toContainEqual({
+      from: 'andre-knie',
+      to: 'python',
+      type: 'has_skill',
+    });
+    expect(result.warnings).toEqual([]);
+  });
+
+  it('infers worked_at from experience organization', async () => {
+    await writeEntity(
+      {
+        id: 'db-cargo',
+        type: 'organization',
+        created: '2025-01-15',
+        modified: '2025-01-15',
+        name: 'DB Cargo AG',
+        industry: 'logistics',
+      },
+      tempDir
+    );
+    await writeEntity(
+      {
+        id: 'lead-innovation',
+        type: 'experience',
+        created: '2025-01-15',
+        modified: '2025-01-15',
+        title: 'Lead Innovation',
+        organization: 'db-cargo',
+        start: '2023-04',
+        end: null,
+      },
+      tempDir
+    );
+
+    const result = await rebuildGraphIndex(tempDir);
+    expect(result.index.relationships).toContainEqual({
+      from: 'lead-innovation',
+      to: 'db-cargo',
+      type: 'worked_at',
+    });
+  });
+
+  it('infers partners_with from tandem entity', async () => {
+    await writeEntity(
+      {
+        id: 'andre-knie',
+        type: 'person',
+        created: '2025-01-15',
+        modified: '2025-01-15',
+        name: { first: 'Andre', last: 'Knie', display: 'Andre Knie' },
+      },
+      tempDir
+    );
+    await writeEntity(
+      {
+        id: 'claudia-froldi',
+        type: 'person',
+        created: '2025-01-15',
+        modified: '2025-01-15',
+        name: { first: 'Claudia', last: 'Froldi', display: 'Claudia Froldi' },
+      },
+      tempDir
+    );
+    await writeEntity(
+      {
+        id: 'froldi-knie',
+        type: 'tandem',
+        created: '2025-01-15',
+        modified: '2025-01-15',
+        partners: ['andre-knie', 'claudia-froldi'],
+        sharedVision: 'Shared vision text',
+        complementarySkills: 'Complementary skills text',
+        collaborationModel: 'Collaboration model text',
+      },
+      tempDir
+    );
+
+    const result = await rebuildGraphIndex(tempDir);
+    expect(result.index.relationships).toContainEqual({
+      from: 'andre-knie',
+      to: 'claudia-froldi',
+      type: 'partners_with',
+      context: 'froldi-knie',
+    });
+  });
+
+  it('infers collaborated_with from project persons', async () => {
+    await writeEntity(
+      {
+        id: 'andre-knie',
+        type: 'person',
+        created: '2025-01-15',
+        modified: '2025-01-15',
+        name: { first: 'Andre', last: 'Knie', display: 'Andre Knie' },
+      },
+      tempDir
+    );
+    await writeEntity(
+      {
+        id: 'claudia-froldi',
+        type: 'person',
+        created: '2025-01-15',
+        modified: '2025-01-15',
+        name: { first: 'Claudia', last: 'Froldi', display: 'Claudia Froldi' },
+      },
+      tempDir
+    );
+    await writeEntity(
+      {
+        id: 'db-cargo',
+        type: 'organization',
+        created: '2025-01-15',
+        modified: '2025-01-15',
+        name: 'DB Cargo AG',
+        industry: 'logistics',
+      },
+      tempDir
+    );
+    await writeEntity(
+      {
+        id: 'ai-project',
+        type: 'project',
+        created: '2025-01-15',
+        modified: '2025-01-15',
+        name: 'AI Project',
+        organization: 'db-cargo',
+        start: '2024-01',
+        persons: ['andre-knie', 'claudia-froldi'],
+      },
+      tempDir
+    );
+
+    const result = await rebuildGraphIndex(tempDir);
+    expect(result.index.relationships).toContainEqual({
+      from: 'andre-knie',
+      to: 'claudia-froldi',
+      type: 'collaborated_with',
+      context: 'ai-project',
+    });
+  });
+
+  it('detects broken references and adds warnings', async () => {
+    await writeEntity(
+      {
+        id: 'andre-knie',
+        type: 'person',
+        created: '2025-01-15',
+        modified: '2025-01-15',
+        name: { first: 'Andre', last: 'Knie', display: 'Andre Knie' },
+        skills: ['nonexistent-skill'],
+      },
+      tempDir
+    );
+
+    const result = await rebuildGraphIndex(tempDir);
+    expect(result.warnings.length).toBeGreaterThan(0);
+    expect(result.warnings[0]).toContain('nonexistent-skill');
+    // Broken references should NOT appear in relationships
+    expect(result.index.relationships).toEqual([]);
+  });
+
+  it('writes index to disk when writeToDisk is true', async () => {
+    await writeEntity(
+      {
+        id: 'python',
+        type: 'skill',
+        created: '2025-01-15',
+        modified: '2025-01-15',
+        name: 'Python',
+        category: 'programming-language',
+        level: 'expert',
+      },
+      tempDir
+    );
+
+    await rebuildGraphIndex(tempDir, true);
+    const index = await readGraphIndex(tempDir);
+    expect(index.entities).toHaveLength(1);
+    expect(index.entities[0].id).toBe('python');
+  });
+
+  it('does not write to disk when writeToDisk is false', async () => {
+    await writeEntity(
+      {
+        id: 'python',
+        type: 'skill',
+        created: '2025-01-15',
+        modified: '2025-01-15',
+        name: 'Python',
+        category: 'programming-language',
+        level: 'expert',
+      },
+      tempDir
+    );
+
+    await rebuildGraphIndex(tempDir, false);
+    const index = await readGraphIndex(tempDir);
+    // No file written, so should be empty
+    expect(index.entities).toEqual([]);
+  });
+
+  it('infers has_skill from experience skillsUsed', async () => {
+    await writeEntity(
+      {
+        id: 'python',
+        type: 'skill',
+        created: '2025-01-15',
+        modified: '2025-01-15',
+        name: 'Python',
+        category: 'programming-language',
+        level: 'expert',
+      },
+      tempDir
+    );
+    await writeEntity(
+      {
+        id: 'db-cargo',
+        type: 'organization',
+        created: '2025-01-15',
+        modified: '2025-01-15',
+        name: 'DB Cargo AG',
+        industry: 'logistics',
+      },
+      tempDir
+    );
+    await writeEntity(
+      {
+        id: 'lead-innovation',
+        type: 'experience',
+        created: '2025-01-15',
+        modified: '2025-01-15',
+        title: 'Lead Innovation',
+        organization: 'db-cargo',
+        start: '2023-04',
+        end: null,
+        skillsUsed: ['python'],
+      },
+      tempDir
+    );
+
+    const result = await rebuildGraphIndex(tempDir);
+    expect(result.index.relationships).toContainEqual({
+      from: 'lead-innovation',
+      to: 'python',
+      type: 'has_skill',
+    });
+  });
+});
+
+// --- Property-Based Tests (fast-check) ---
+
+import fc from 'fast-check';
+import { validateTandem } from '../schemas/validate';
+
+// --- Arbitraries (reusing patterns from validate.test.ts) ---
+
+/** Generates a valid kebab-case ID */
+const kebabCaseId = fc
+  .array(
+    fc.stringMatching(/^[a-z0-9]{1,8}$/),
+    { minLength: 1, maxLength: 3 }
+  )
+  .map(parts => parts.join('-'));
+
+/** Generates a valid ISO date (YYYY-MM or YYYY-MM-DD) */
+const isoDate = fc.oneof(
+  fc.record({
+    year: fc.integer({ min: 1990, max: 2030 }),
+    month: fc.integer({ min: 1, max: 12 }),
+  }).map(({ year, month }) => `${year}-${String(month).padStart(2, '0')}`),
+  fc.record({
+    year: fc.integer({ min: 1990, max: 2030 }),
+    month: fc.integer({ min: 1, max: 12 }),
+    day: fc.integer({ min: 1, max: 28 }),
+  }).map(({ year, month, day }) => `${year}-${String(month).padStart(2, '0')}-${String(day).padStart(2, '0')}`)
+);
+
+/** Valid relationship types */
+const VALID_RELATIONSHIP_TYPES = ['has_skill', 'worked_at', 'collaborated_with', 'applied_for', 'partners_with'] as const;
+
+/** Generates a unique set of kebab-case IDs */
+const uniqueKebabIds = (minLength: number, maxLength: number) =>
+  fc.uniqueArray(kebabCaseId, { minLength, maxLength, comparator: (a, b) => a === b });
+
+/** Generates a valid Skill entity for writing */
+const skillEntityArb = (id: string) =>
+  fc.record({
+    created: isoDate,
+    modified: isoDate,
+    name: fc.string({ minLength: 1, maxLength: 20 }).filter(s => s.trim().length > 0),
+    category: fc.constantFrom('programming-language' as const, 'framework' as const, 'methodology' as const, 'soft-skill' as const, 'domain' as const),
+    level: fc.constantFrom('beginner' as const, 'intermediate' as const, 'advanced' as const, 'expert' as const),
+  }).map(fields => ({
+    id,
+    type: 'skill' as const,
+    ...fields,
+  }));
+
+/** Generates a valid Organization entity for writing */
+const orgEntityArb = (id: string) =>
+  fc.record({
+    created: isoDate,
+    modified: isoDate,
+    name: fc.string({ minLength: 1, maxLength: 20 }).filter(s => s.trim().length > 0),
+    industry: fc.string({ minLength: 1, maxLength: 20 }).filter(s => s.trim().length > 0),
+  }).map(fields => ({
+    id,
+    type: 'organization' as const,
+    ...fields,
+  }));
+
+/** Generates a valid Person entity for writing */
+const personEntityArb = (id: string) =>
+  fc.record({
+    created: isoDate,
+    modified: isoDate,
+    first: fc.string({ minLength: 1, maxLength: 15 }).filter(s => s.trim().length > 0),
+    last: fc.string({ minLength: 1, maxLength: 15 }).filter(s => s.trim().length > 0),
+    display: fc.string({ minLength: 1, maxLength: 30 }).filter(s => s.trim().length > 0),
+  }).map(fields => ({
+    id,
+    type: 'person' as const,
+    created: fields.created,
+    modified: fields.modified,
+    name: { first: fields.first, last: fields.last, display: fields.display },
+  }));
+
+// --- Property 4: Graph index consistency ---
+
+describe('Property 4: Graph index consistency', () => {
+  /**
+   * Validates: Requirements 1.2, 9.4
+   */
+
+  it('after rebuilding, the graph index lists exactly the entities written (no missing, no extra)', async () => {
+    await fc.assert(
+      fc.asyncProperty(
+        uniqueKebabIds(1, 5).chain(skillIds =>
+          fc.tuple(
+            fc.constant(skillIds),
+            ...skillIds.map(id => skillEntityArb(id))
+          )
+        ),
+        async (tuple) => {
+          const [ids, ...entities] = tuple as [string[], ...any[]];
+          const dir = await mkdtemp(join(tmpdir(), 'prop4-'));
+          try {
+            for (const entity of entities) {
+              await writeEntity(entity, dir);
+            }
+            const result = await rebuildGraphIndex(dir);
+            const indexIds = result.index.entities.map(e => e.id).sort();
+            expect(indexIds).toEqual([...ids].sort());
+          } finally {
+            await rm(dir, { recursive: true, force: true });
+          }
+        }
+      ),
+      { numRuns: 100 }
+    );
+  });
+
+  it('all relationships reference entity IDs that exist in the entities list', async () => {
+    await fc.assert(
+      fc.asyncProperty(
+        uniqueKebabIds(2, 4).chain(personIds =>
+          uniqueKebabIds(1, 3).chain(skillIds => {
+            // Ensure no overlap between person and skill IDs
+            const filteredSkillIds = skillIds.filter(s => !personIds.includes(s));
+            if (filteredSkillIds.length === 0) return fc.constant(null);
+            return fc.tuple(
+              fc.constant(personIds),
+              fc.constant(filteredSkillIds),
+              ...personIds.map(id => personEntityArb(id)),
+              ...filteredSkillIds.map(id => skillEntityArb(id)),
+            );
+          })
+        ).filter(v => v !== null),
+        async (tuple) => {
+          const arr = tuple as any[];
+          const personIds = arr[0] as string[];
+          const skillIds = arr[1] as string[];
+          const personEntities = arr.slice(2, 2 + personIds.length);
+          const skillEntities = arr.slice(2 + personIds.length);
+
+          // Assign skills to persons so relationships are inferred
+          const personsWithSkills = personEntities.map((p: any, i: number) => ({
+            ...p,
+            skills: [skillIds[i % skillIds.length]],
+          }));
+
+          const dir = await mkdtemp(join(tmpdir(), 'prop4b-'));
+          try {
+            for (const entity of [...personsWithSkills, ...skillEntities]) {
+              await writeEntity(entity, dir);
+            }
+            const result = await rebuildGraphIndex(dir);
+            const entityIdSet = new Set(result.index.entities.map(e => e.id));
+
+            for (const rel of result.index.relationships) {
+              expect(entityIdSet.has(rel.from)).toBe(true);
+              expect(entityIdSet.has(rel.to)).toBe(true);
+            }
+          } finally {
+            await rm(dir, { recursive: true, force: true });
+          }
+        }
+      ),
+      { numRuns: 100 }
+    );
+  });
+
+  it('all relationship types are from the defined set', async () => {
+    await fc.assert(
+      fc.asyncProperty(
+        uniqueKebabIds(2, 3).chain(personIds =>
+          uniqueKebabIds(1, 2).chain(skillIds => {
+            const filteredSkillIds = skillIds.filter(s => !personIds.includes(s));
+            if (filteredSkillIds.length === 0) return fc.constant(null);
+            return fc.tuple(
+              fc.constant(personIds),
+              fc.constant(filteredSkillIds),
+              ...personIds.map(id => personEntityArb(id)),
+              ...filteredSkillIds.map(id => skillEntityArb(id)),
+            );
+          })
+        ).filter(v => v !== null),
+        async (tuple) => {
+          const arr = tuple as any[];
+          const personIds = arr[0] as string[];
+          const skillIds = arr[1] as string[];
+          const personEntities = arr.slice(2, 2 + personIds.length);
+          const skillEntities = arr.slice(2 + personIds.length);
+
+          const personsWithSkills = personEntities.map((p: any, i: number) => ({
+            ...p,
+            skills: [skillIds[i % skillIds.length]],
+          }));
+
+          const dir = await mkdtemp(join(tmpdir(), 'prop4c-'));
+          try {
+            for (const entity of [...personsWithSkills, ...skillEntities]) {
+              await writeEntity(entity, dir);
+            }
+            const result = await rebuildGraphIndex(dir);
+
+            for (const rel of result.index.relationships) {
+              expect(VALID_RELATIONSHIP_TYPES).toContain(rel.type);
+            }
+          } finally {
+            await rm(dir, { recursive: true, force: true });
+          }
+        }
+      ),
+      { numRuns: 100 }
+    );
+  });
+});
+
+// --- Property 5: Tandem entity integrity ---
+
+describe('Property 5: Tandem entity integrity', () => {
+  /**
+   * Validates: Requirements 2.3, 2.4
+   */
+
+  it('a valid tandem references exactly two partners and contains all tandem-specific fields', async () => {
+    await fc.assert(
+      fc.asyncProperty(
+        uniqueKebabIds(3, 3).chain(ids => {
+          const [tandemId, partner1Id, partner2Id] = ids;
+          return fc.tuple(
+            fc.constant(tandemId),
+            fc.constant(partner1Id),
+            fc.constant(partner2Id),
+            personEntityArb(partner1Id),
+            personEntityArb(partner2Id),
+            fc.record({
+              created: isoDate,
+              modified: isoDate,
+              sharedVision: fc.string({ minLength: 1, maxLength: 50 }).filter(s => s.trim().length > 0),
+              complementarySkills: fc.string({ minLength: 1, maxLength: 50 }).filter(s => s.trim().length > 0),
+              collaborationModel: fc.string({ minLength: 1, maxLength: 50 }).filter(s => s.trim().length > 0),
+            }),
+          );
+        }),
+        async ([tandemId, partner1Id, partner2Id, person1, person2, tandemFields]) => {
+          const tandemEntity = {
+            id: tandemId,
+            type: 'tandem' as const,
+            created: tandemFields.created,
+            modified: tandemFields.modified,
+            partners: [partner1Id, partner2Id] as [string, string],
+            sharedVision: tandemFields.sharedVision,
+            complementarySkills: tandemFields.complementarySkills,
+            collaborationModel: tandemFields.collaborationModel,
+          };
+
+          // Validate the tandem entity passes schema validation
+          const validationResult = validateTandem(tandemEntity as any);
+          expect(validationResult.valid).toBe(true);
+
+          // Verify it has exactly 2 partners
+          expect(tandemEntity.partners).toHaveLength(2);
+
+          // Verify all tandem-specific fields are present and non-empty
+          expect(tandemEntity.sharedVision.trim().length).toBeGreaterThan(0);
+          expect(tandemEntity.complementarySkills.trim().length).toBeGreaterThan(0);
+          expect(tandemEntity.collaborationModel.trim().length).toBeGreaterThan(0);
+
+          // Write to disk and rebuild to verify partners reference existing persons
+          const dir = await mkdtemp(join(tmpdir(), 'prop5-'));
+          try {
+            await writeEntity(person1 as any, dir);
+            await writeEntity(person2 as any, dir);
+            await writeEntity(tandemEntity as any, dir);
+
+            const result = await rebuildGraphIndex(dir);
+
+            // Both partners should exist in the entity list
+            const entityIds = new Set(result.index.entities.map(e => e.id));
+            expect(entityIds.has(partner1Id)).toBe(true);
+            expect(entityIds.has(partner2Id)).toBe(true);
+
+            // The tandem should produce a partners_with relationship
+            const partnerRels = result.index.relationships.filter(r => r.type === 'partners_with');
+            expect(partnerRels.length).toBeGreaterThan(0);
+            // The relationship should reference both partners
+            const partnerRel = partnerRels.find(
+              r => (r.from === partner1Id && r.to === partner2Id) ||
+                   (r.from === partner2Id && r.to === partner1Id)
+            );
+            expect(partnerRel).toBeDefined();
+          } finally {
+            await rm(dir, { recursive: true, force: true });
+          }
+        }
+      ),
+      { numRuns: 100 }
+    );
+  });
+
+  it('a tandem without exactly 2 partners fails validation', () => {
+    fc.assert(
+      fc.property(
+        kebabCaseId,
+        isoDate,
+        isoDate,
+        fc.array(kebabCaseId, { minLength: 0, maxLength: 5 }).filter(arr => arr.length !== 2),
+        fc.string({ minLength: 1, maxLength: 50 }).filter(s => s.trim().length > 0),
+        fc.string({ minLength: 1, maxLength: 50 }).filter(s => s.trim().length > 0),
+        fc.string({ minLength: 1, maxLength: 50 }).filter(s => s.trim().length > 0),
+        (id, created, modified, partners, sharedVision, complementarySkills, collaborationModel) => {
+          const tandem = {
+            id,
+            type: 'tandem',
+            created,
+            modified,
+            partners,
+            sharedVision,
+            complementarySkills,
+            collaborationModel,
+          };
+          const result = validateTandem(tandem as any);
+          expect(result.valid).toBe(false);
+          expect(result.errors.some(e => e.includes('exactly 2') || e.includes('must be an array'))).toBe(true);
+        }
+      ),
+      { numRuns: 100 }
+    );
+  });
+
+  it('a tandem missing any tandem-specific field fails validation', () => {
+    fc.assert(
+      fc.property(
+        kebabCaseId,
+        isoDate,
+        isoDate,
+        kebabCaseId,
+        kebabCaseId,
+        fc.constantFrom('sharedVision', 'complementarySkills', 'collaborationModel'),
+        (id, created, modified, partner1, partner2, fieldToRemove) => {
+          const tandem: Record<string, unknown> = {
+            id,
+            type: 'tandem',
+            created,
+            modified,
+            partners: [partner1, partner2],
+            sharedVision: 'Shared vision text',
+            complementarySkills: 'Complementary skills text',
+            collaborationModel: 'Collaboration model text',
+          };
+          delete tandem[fieldToRemove];
+          const result = validateTandem(tandem as any);
+          expect(result.valid).toBe(false);
+          expect(result.errors.some(e => e.includes(fieldToRemove))).toBe(true);
+        }
+      ),
+      { numRuns: 100 }
+    );
+  });
+});

privat/CV/src/graph/index-manager.ts

@@ -0,0 +1,300 @@
+/**
+ * Graph index read/write logic for the knowledge base.
+ *
+ * Manages `kb/graph-index.yaml` — the central index of all entities and relationships.
+ */
+
+import { readFile, writeFile, mkdir } from 'node:fs/promises';
+import { join, dirname } from 'node:path';
+import { parse, stringify } from 'yaml';
+import type {
+  GraphIndex,
+  GraphEntity,
+  GraphRelationship,
+  RelationshipType,
+  EntityType,
+  Entity,
+} from '../schemas/types';
+import { listEntities, readEntity } from '../io/entity-files';
+
+const GRAPH_INDEX_PATH = join('kb', 'graph-index.yaml');
+
+const VALID_RELATIONSHIP_TYPES: ReadonlySet<string> = new Set<RelationshipType>([
+  'has_skill',
+  'worked_at',
+  'collaborated_with',
+  'applied_for',
+  'partners_with',
+]);
+
+/**
+ * Returns the full path to the graph index file.
+ */
+export function getGraphIndexPath(basePath: string = process.cwd()): string {
+  return join(basePath, GRAPH_INDEX_PATH);
+}
+
+/**
+ * Reads the graph index from disk.
+ * Returns an empty index if the file doesn't exist yet.
+ */
+export async function readGraphIndex(basePath: string = process.cwd()): Promise<GraphIndex> {
+  const filePath = getGraphIndexPath(basePath);
+  let content: string;
+  try {
+    content = await readFile(filePath, 'utf-8');
+  } catch (err: unknown) {
+    if (err instanceof Error && 'code' in err && (err as NodeJS.ErrnoException).code === 'ENOENT') {
+      return { entities: [], relationships: [] };
+    }
+    throw err;
+  }
+  const parsed = parse(content);
+  if (!parsed) {
+    return { entities: [], relationships: [] };
+  }
+  return {
+    entities: Array.isArray(parsed.entities) ? parsed.entities : [],
+    relationships: Array.isArray(parsed.relationships) ? parsed.relationships : [],
+  };
+}
+
+/**
+ * Writes the graph index to disk.
+ * Creates the parent directory if it doesn't exist.
+ */
+export async function writeGraphIndex(index: GraphIndex, basePath: string = process.cwd()): Promise<void> {
+  const filePath = getGraphIndexPath(basePath);
+  await mkdir(dirname(filePath), { recursive: true });
+  const yaml = stringify(index, { lineWidth: 0 });
+  await writeFile(filePath, yaml, 'utf-8');
+}
+
+/**
+ * Adds an entity to the graph index.
+ * If an entity with the same ID already exists, it is replaced.
+ */
+export async function addEntity(entity: GraphEntity, basePath: string = process.cwd()): Promise<void> {
+  const index = await readGraphIndex(basePath);
+  const existing = index.entities.findIndex((e) => e.id === entity.id);
+  if (existing >= 0) {
+    index.entities[existing] = entity;
+  } else {
+    index.entities.push(entity);
+  }
+  await writeGraphIndex(index, basePath);
+}
+
+/**
+ * Removes an entity from the graph index by ID.
+ * Also removes any relationships that reference the entity.
+ */
+export async function removeEntity(entityId: string, basePath: string = process.cwd()): Promise<void> {
+  const index = await readGraphIndex(basePath);
+  index.entities = index.entities.filter((e) => e.id !== entityId);
+  index.relationships = index.relationships.filter(
+    (r) => r.from !== entityId && r.to !== entityId
+  );
+  await writeGraphIndex(index, basePath);
+}
+
+/**
+ * Validates that a relationship type is from the defined set.
+ * Throws an error if the type is invalid.
+ */
+export function validateRelationshipType(type: string): asserts type is RelationshipType {
+  if (!VALID_RELATIONSHIP_TYPES.has(type)) {
+    throw new Error(
+      `Invalid relationship type "${type}". Must be one of: ${[...VALID_RELATIONSHIP_TYPES].join(', ')}`
+    );
+  }
+}
+
+/**
+ * Adds a relationship to the graph index.
+ * Validates the relationship type before adding.
+ * If an identical relationship already exists, it is not duplicated.
+ */
+export async function addRelationship(relationship: GraphRelationship, basePath: string = process.cwd()): Promise<void> {
+  validateRelationshipType(relationship.type);
+  const index = await readGraphIndex(basePath);
+  const duplicate = index.relationships.some(
+    (r) => r.from === relationship.from && r.to === relationship.to && r.type === relationship.type
+  );
+  if (!duplicate) {
+    index.relationships.push(relationship);
+    await writeGraphIndex(index, basePath);
+  }
+}
+
+/**
+ * Removes a relationship from the graph index.
+ * Matches on from, to, and type.
+ */
+export async function removeRelationship(
+  from: string,
+  to: string,
+  type: RelationshipType,
+  basePath: string = process.cwd()
+): Promise<void> {
+  const index = await readGraphIndex(basePath);
+  index.relationships = index.relationships.filter(
+    (r) => !(r.from === from && r.to === to && r.type === type)
+  );
+  await writeGraphIndex(index, basePath);
+}
+
+/**
+ * Result of a graph index rebuild operation.
+ */
+export interface RebuildResult {
+  index: GraphIndex;
+  warnings: string[];
+}
+
+/** All entity types to scan during rebuild. */
+const ALL_ENTITY_TYPES: EntityType[] = [
+  'person',
+  'experience',
+  'skill',
+  'organization',
+  'project',
+  'certification',
+  'tandem',
+];
+
+/**
+ * Extracts the display name from an entity based on its type.
+ */
+function getEntityDisplayName(entity: Entity): string {
+  switch (entity.type) {
+    case 'person':
+      return entity.name.display;
+    case 'experience':
+      return entity.title;
+    case 'skill':
+      return entity.name;
+    case 'organization':
+      return entity.name;
+    case 'project':
+      return entity.name;
+    case 'certification':
+      return entity.name;
+    case 'tandem':
+      return entity.partners.join(' & ');
+  }
+}
+
+/**
+ * Rebuilds the graph index by scanning all entity directories.
+ *
+ * Reads every entity file, builds the entities list, infers relationships,
+ * and detects broken references (entity IDs referenced but no file exists).
+ *
+ * @param basePath - Root directory of the project (for testability)
+ * @param writeToDisk - If true, writes the rebuilt index to kb/graph-index.yaml
+ * @returns The rebuilt index and a list of broken reference warnings
+ */
+export async function rebuildGraphIndex(
+  basePath: string = process.cwd(),
+  writeToDisk: boolean = false
+): Promise<RebuildResult> {
+  const entities: GraphEntity[] = [];
+  const relationships: GraphRelationship[] = [];
+  const warnings: string[] = [];
+  const knownIds = new Set<string>();
+
+  // Phase 1: Scan all entity directories and build entity list
+  const entityMap = new Map<string, Entity>();
+
+  for (const type of ALL_ENTITY_TYPES) {
+    const ids = await listEntities(type, basePath);
+    for (const id of ids) {
+      let entity: Entity;
+      try {
+        entity = await readEntity(type, id, basePath);
+      } catch {
+        warnings.push(`Failed to read ${type} entity "${id}"`);
+        continue;
+      }
+      knownIds.add(id);
+      entityMap.set(id, entity);
+      entities.push({
+        id: entity.id,
+        type: entity.type,
+        name: getEntityDisplayName(entity),
+      });
+    }
+  }
+
+  // Phase 2: Infer relationships from entity data
+  const addedRelationships = new Set<string>();
+
+  function addRel(from: string, to: string, type: RelationshipType, context?: string): void {
+    const key = `${from}|${to}|${type}`;
+    if (addedRelationships.has(key)) return;
+    addedRelationships.add(key);
+
+    if (!knownIds.has(to)) {
+      warnings.push(`Broken reference: ${from} → ${to} (type: ${type})`);
+      return;
+    }
+    const rel: GraphRelationship = { from, to, type };
+    if (context) rel.context = context;
+    relationships.push(rel);
+  }
+
+  for (const [id, entity] of entityMap) {
+    switch (entity.type) {
+      case 'person': {
+        if (entity.skills) {
+          for (const skillId of entity.skills) {
+            addRel(id, skillId, 'has_skill');
+          }
+        }
+        if (entity.experiences) {
+          for (const expId of entity.experiences) {
+            const exp = entityMap.get(expId);
+            if (exp && exp.type === 'experience') {
+              addRel(id, exp.organization, 'worked_at', expId);
+            }
+          }
+        }
+        break;
+      }
+      case 'experience': {
+        addRel(id, entity.organization, 'worked_at');
+        if (entity.skillsUsed) {
+          for (const skillId of entity.skillsUsed) {
+            addRel(id, skillId, 'has_skill');
+          }
+        }
+        break;
+      }
+      case 'project': {
+        addRel(id, entity.organization, 'worked_at');
+        if (entity.persons) {
+          for (let i = 0; i < entity.persons.length; i++) {
+            for (let j = i + 1; j < entity.persons.length; j++) {
+              addRel(entity.persons[i], entity.persons[j], 'collaborated_with', id);
+            }
+          }
+        }
+        break;
+      }
+      case 'tandem': {
+        const [p1, p2] = entity.partners;
+        addRel(p1, p2, 'partners_with', id);
+        break;
+      }
+    }
+  }
+
+  const index: GraphIndex = { entities, relationships };
+
+  if (writeToDisk) {
+    await writeGraphIndex(index, basePath);
+  }
+
+  return { index, warnings };
+}

privat/CV/src/index.ts

@@ -0,0 +1,54 @@
+/**
+ * Personal Knowledge Base
+ *
+ * A file-based personal knowledge graph with YAML entity storage,
+ * graph index, and Kiro skills for CV generation, interviews, and reviews.
+ */
+
+// --- LinkedIn Module ---
+
+export { generateHeadlines } from './linkedin/headline-generator';
+export { generateAbout } from './linkedin/about-generator';
+export { generateExperiences } from './linkedin/experience-generator';
+export { generateContentStrategy } from './linkedin/content-strategy';
+export { addTrackingEntry, getWeeklyReport, getMonthlyTrend } from './linkedin/tracking-manager';
+export {
+  validateHeadline,
+  validateAbout,
+  validateExperience,
+  HEADLINE_CHAR_LIMIT,
+  ABOUT_CHAR_LIMIT,
+  EXPERIENCE_CHAR_LIMIT,
+} from './linkedin/constraints';
+export { generateProfileOutput } from './linkedin/profile-output';
+export type { ProfileOutputOptions, ProfileOutputResult } from './linkedin/profile-output';
+export { writeContentStrategyOutput, formatStrategyMarkdown } from './linkedin/strategy-output';
+export type { StrategyOutputOptions } from './linkedin/strategy-output';
+export { generateTrackingReport } from './linkedin/tracking-output';
+export type { TrackingReportOptions, TrackingReportResult } from './linkedin/tracking-output';
+
+// Types
+export type {
+  HeadlineOptions,
+  HeadlineResult,
+  HeadlineVariant,
+  AboutOptions,
+  AboutResult,
+  ExperienceOptions,
+  ExperienceResult,
+  ContentStrategyOptions,
+  ContentStrategy,
+  ThemeCluster,
+  WeeklySlot,
+  EngagementRoutine,
+  FormatMix,
+  TrackingEntry,
+  PostMetric,
+  WeeklyReport,
+  MonthlyTrend,
+} from './linkedin/types';
+export type {
+  ConstraintValidation,
+  ConstraintError,
+  ConstraintWarning,
+} from './linkedin/constraints';

privat/CV/src/interview/conflict-detection.ts

@@ -0,0 +1,122 @@
+/**
+ * Conflict Detection — identifies fields where a proposed update
+ * differs from the existing entity value.
+ *
+ * Pure function, no I/O.
+ */
+
+import type { Entity } from '../schemas/types';
+
+// --- Types ---
+
+export interface Conflict {
+  /** Dot-notation path to the conflicting field */
+  fieldPath: string;
+  /** The current value in the existing entity */
+  existingValue: unknown;
+  /** The proposed new value */
+  proposedValue: unknown;
+}
+
+// --- Helpers ---
+
+/**
+ * Deep equality check for JSON-serializable values.
+ */
+function deepEqual(a: unknown, b: unknown): boolean {
+  if (a === b) return true;
+  if (a === null || b === null) return false;
+  if (a === undefined || b === undefined) return false;
+  if (typeof a !== typeof b) return false;
+
+  if (Array.isArray(a) && Array.isArray(b)) {
+    if (a.length !== b.length) return false;
+    return a.every((item, i) => deepEqual(item, b[i]));
+  }
+
+  if (typeof a === 'object' && typeof b === 'object') {
+    const aObj = a as Record<string, unknown>;
+    const bObj = b as Record<string, unknown>;
+    const aKeys = Object.keys(aObj);
+    const bKeys = Object.keys(bObj);
+    if (aKeys.length !== bKeys.length) return false;
+    return aKeys.every((key) => deepEqual(aObj[key], bObj[key]));
+  }
+
+  return false;
+}
+
+/**
+ * Resolves a dot-notation field path on an object.
+ */
+function getNestedValue(obj: Record<string, unknown>, path: string): unknown {
+  const parts = path.split('.');
+  let current: unknown = obj;
+  for (const part of parts) {
+    if (current === null || current === undefined || typeof current !== 'object') {
+      return undefined;
+    }
+    current = (current as Record<string, unknown>)[part];
+  }
+  return current;
+}
+
+/**
+ * Flattens a nested object into dot-notation paths with their values.
+ * Only flattens plain objects, not arrays.
+ */
+function flattenPaths(
+  obj: Record<string, unknown>,
+  prefix = ''
+): Array<{ path: string; value: unknown }> {
+  const results: Array<{ path: string; value: unknown }> = [];
+
+  for (const key of Object.keys(obj)) {
+    const fullPath = prefix ? `${prefix}.${key}` : key;
+    const value = obj[key];
+
+    if (
+      value !== null &&
+      value !== undefined &&
+      typeof value === 'object' &&
+      !Array.isArray(value)
+    ) {
+      results.push(...flattenPaths(value as Record<string, unknown>, fullPath));
+    } else {
+      results.push({ path: fullPath, value });
+    }
+  }
+
+  return results;
+}
+
+// --- Main Function ---
+
+/**
+ * Detects conflicts between an existing entity and a proposed update.
+ * A conflict exists when the proposed value for a field differs from the existing value
+ * and the existing value is already set (not undefined/null).
+ */
+export function detectConflicts(
+  existing: Entity,
+  proposed: Record<string, unknown>
+): Conflict[] {
+  const conflicts: Conflict[] = [];
+  const existingObj = existing as unknown as Record<string, unknown>;
+  const flatProposed = flattenPaths(proposed);
+
+  for (const { path, value: proposedValue } of flatProposed) {
+    const existingValue = getNestedValue(existingObj, path);
+
+    // Only flag as conflict if existing value is set and differs
+    if (existingValue !== undefined && existingValue !== null && !deepEqual(existingValue, proposedValue)) {
+      conflicts.push({
+        fieldPath: path,
+        existingValue,
+        proposedValue,
+      });
+    }
+  }
+
+  return conflicts;
+}

privat/CV/src/interview/gap-detection.ts

@@ -0,0 +1,162 @@
+/**
+ * Gap Detection — identifies missing/incomplete attributes on entities.
+ *
+ * Pure function, no I/O. Returns gaps sorted by priority (required first, then optional).
+ */
+
+import type { Entity, EntityType } from '../schemas/types';
+
+// --- Types ---
+
+export interface Gap {
+  /** The field name (dot-notation for nested, e.g. "name.first") */
+  field: string;
+  /** Whether this field is required for the entity type */
+  required: boolean;
+  /** Human-readable description of what's missing */
+  description: string;
+}
+
+// --- Field Definitions per Entity Type ---
+
+interface FieldDef {
+  field: string;
+  required: boolean;
+  description: string;
+}
+
+const PERSON_FIELDS: FieldDef[] = [
+  { field: 'name.first', required: true, description: 'First name' },
+  { field: 'name.last', required: true, description: 'Last name' },
+  { field: 'name.display', required: true, description: 'Display name' },
+  { field: 'contact', required: false, description: 'Contact information' },
+  { field: 'summary', required: false, description: 'Professional summary' },
+  { field: 'languages', required: false, description: 'Languages spoken' },
+  { field: 'education', required: false, description: 'Education history' },
+  { field: 'skills', required: false, description: 'Skills references' },
+  { field: 'experiences', required: false, description: 'Experience references' },
+  { field: 'certifications', required: false, description: 'Certification references' },
+];
+
+const EXPERIENCE_FIELDS: FieldDef[] = [
+  { field: 'title', required: true, description: 'Job title' },
+  { field: 'organization', required: true, description: 'Organization reference' },
+  { field: 'start', required: true, description: 'Start date' },
+  { field: 'description', required: false, description: 'Role description' },
+  { field: 'achievements', required: false, description: 'Achievements list' },
+  { field: 'skillsUsed', required: false, description: 'Skills used in this role' },
+];
+
+const SKILL_FIELDS: FieldDef[] = [
+  { field: 'name', required: true, description: 'Skill name' },
+  { field: 'category', required: true, description: 'Skill category' },
+  { field: 'level', required: true, description: 'Proficiency level' },
+  { field: 'years', required: false, description: 'Years of experience' },
+  { field: 'context', required: false, description: 'Context of skill usage' },
+];
+
+const ORGANIZATION_FIELDS: FieldDef[] = [
+  { field: 'name', required: true, description: 'Organization name' },
+  { field: 'industry', required: true, description: 'Industry sector' },
+  { field: 'parent', required: false, description: 'Parent organization' },
+  { field: 'website', required: false, description: 'Website URL' },
+];
+
+const PROJECT_FIELDS: FieldDef[] = [
+  { field: 'name', required: true, description: 'Project name' },
+  { field: 'organization', required: true, description: 'Organization reference' },
+  { field: 'start', required: true, description: 'Start date' },
+  { field: 'description', required: false, description: 'Project description' },
+  { field: 'end', required: false, description: 'End date' },
+  { field: 'skillsUsed', required: false, description: 'Skills used in this project' },
+  { field: 'persons', required: false, description: 'Persons involved' },
+];
+
+const CERTIFICATION_FIELDS: FieldDef[] = [
+  { field: 'name', required: true, description: 'Certification name' },
+  { field: 'issuer', required: true, description: 'Issuing organization' },
+  { field: 'date', required: true, description: 'Date obtained' },
+  { field: 'person', required: true, description: 'Person reference' },
+  { field: 'expires', required: false, description: 'Expiration date' },
+];
+
+const TANDEM_FIELDS: FieldDef[] = [
+  { field: 'partners', required: true, description: 'Partner references (exactly 2)' },
+  { field: 'sharedVision', required: true, description: 'Shared professional vision' },
+  { field: 'complementarySkills', required: true, description: 'Complementary skills description' },
+  { field: 'collaborationModel', required: true, description: 'Collaboration model description' },
+  { field: 'combinedNarrative', required: false, description: 'Combined professional narrative' },
+  { field: 'jointCompetencies', required: false, description: 'Joint competencies list' },
+];
+
+const FIELD_DEFS: Record<EntityType, FieldDef[]> = {
+  person: PERSON_FIELDS,
+  experience: EXPERIENCE_FIELDS,
+  skill: SKILL_FIELDS,
+  organization: ORGANIZATION_FIELDS,
+  project: PROJECT_FIELDS,
+  certification: CERTIFICATION_FIELDS,
+  tandem: TANDEM_FIELDS,
+};
+
+// --- Helpers ---
+
+/**
+ * Resolves a dot-notation field path on an object.
+ * Returns undefined if any segment is missing.
+ */
+function getNestedValue(obj: Record<string, unknown>, path: string): unknown {
+  const parts = path.split('.');
+  let current: unknown = obj;
+  for (const part of parts) {
+    if (current === null || current === undefined || typeof current !== 'object') {
+      return undefined;
+    }
+    current = (current as Record<string, unknown>)[part];
+  }
+  return current;
+}
+
+/**
+ * Checks whether a value counts as "filled" (not missing/empty).
+ */
+function isFilled(value: unknown): boolean {
+  if (value === undefined || value === null) return false;
+  if (typeof value === 'string' && value.trim() === '') return false;
+  if (Array.isArray(value) && value.length === 0) return false;
+  return true;
+}
+
+// --- Main Function ---
+
+/**
+ * Detects gaps (missing/incomplete attributes) on an entity.
+ * Returns gaps sorted by priority: required gaps first, then optional.
+ */
+export function detectGaps(entity: Entity): Gap[] {
+  const fieldDefs = FIELD_DEFS[entity.type];
+  if (!fieldDefs) return [];
+
+  const gaps: Gap[] = [];
+  const obj = entity as unknown as Record<string, unknown>;
+
+  for (const def of fieldDefs) {
+    const value = getNestedValue(obj, def.field);
+    if (!isFilled(value)) {
+      gaps.push({
+        field: def.field,
+        required: def.required,
+        description: def.description,
+      });
+    }
+  }
+
+  // Sort: required first, then optional (stable within each group)
+  gaps.sort((a, b) => {
+    if (a.required && !b.required) return -1;
+    if (!a.required && b.required) return 1;
+    return 0;
+  });
+
+  return gaps;
+}

privat/CV/src/interview/interview.test.ts

@@ -0,0 +1,245 @@
+import { describe, it, expect } from 'vitest';
+import fc from 'fast-check';
+import { detectGaps } from '../interview/gap-detection';
+import { detectConflicts } from '../interview/conflict-detection';
+import type { Person, Entity } from '../schemas/types';
+
+// --- Arbitraries ---
+
+/** Generates a valid kebab-case ID */
+const kebabCaseId = fc
+  .array(
+    fc.stringMatching(/^[a-z0-9]{1,8}$/),
+    { minLength: 1, maxLength: 4 }
+  )
+  .map(parts => parts.join('-'));
+
+/** Generates a valid ISO date */
+const isoDate = fc
+  .record({
+    year: fc.integer({ min: 1990, max: 2030 }),
+    month: fc.integer({ min: 1, max: 12 }),
+  })
+  .map(({ year, month }) => `${year}-${String(month).padStart(2, '0')}`);
+
+/** Generates a Person entity with varying completeness (some optional fields present, some missing) */
+const personWithGaps = fc.record({
+  id: kebabCaseId,
+  created: isoDate,
+  modified: isoDate,
+  hasFirst: fc.boolean(),
+  hasLast: fc.boolean(),
+  hasDisplay: fc.boolean(),
+  hasContact: fc.boolean(),
+  hasSummary: fc.boolean(),
+  hasLanguages: fc.boolean(),
+  hasEducation: fc.boolean(),
+  hasSkills: fc.boolean(),
+  hasExperiences: fc.boolean(),
+  hasCertifications: fc.boolean(),
+}).map(fields => {
+  const person: Record<string, unknown> = {
+    id: fields.id,
+    type: 'person',
+    created: fields.created,
+    modified: fields.modified,
+  };
+
+  // Name is a nested object — build it conditionally
+  const name: Record<string, string> = {};
+  if (fields.hasFirst) name.first = 'Andre';
+  if (fields.hasLast) name.last = 'Knie';
+  if (fields.hasDisplay) name.display = 'Andre Knie';
+
+  if (Object.keys(name).length > 0) {
+    person.name = name;
+  }
+
+  if (fields.hasContact) person.contact = { email: 'test@example.com' };
+  if (fields.hasSummary) person.summary = 'A professional summary.';
+  if (fields.hasLanguages) person.languages = [{ language: 'German', level: 'native' }];
+  if (fields.hasEducation) person.education = [{ institution: 'TU', degree: 'MSc', field: 'CS', start: '2000-09', end: '2004-06' }];
+  if (fields.hasSkills) person.skills = ['python', 'typescript'];
+  if (fields.hasExperiences) person.experiences = ['exp-1'];
+  if (fields.hasCertifications) person.certifications = ['cert-1'];
+
+  return person as unknown as Person;
+});
+
+/** Generates a complete Person entity (all fields filled) */
+const completePerson = fc.record({
+  id: kebabCaseId,
+  created: isoDate,
+  modified: isoDate,
+}).map(fields => ({
+  id: fields.id,
+  type: 'person' as const,
+  created: fields.created,
+  modified: fields.modified,
+  name: { first: 'Andre', last: 'Knie', display: 'Andre Knie' },
+  contact: { email: 'test@example.com', linkedin: 'linkedin.com/in/test' },
+  summary: 'Professional summary text.',
+  languages: [{ language: 'German', level: 'native' }],
+  education: [{ institution: 'TU Berlin', degree: 'MSc', field: 'CS', start: '2000-09', end: '2004-06' }],
+  skills: ['python', 'typescript'],
+  experiences: ['exp-1', 'exp-2'],
+  certifications: ['cert-1'],
+}));
+
+// --- Property 6: Interview session question limit (≤ 10) ---
+
+describe('Property 6: Interview session question limit', () => {
+  it('gap detection returns a number of gaps that can be capped at 10 for any person profile', () => {
+    fc.assert(
+      fc.property(personWithGaps, (person) => {
+        const gaps = detectGaps(person);
+        // The interview skill enforces a max of 10 questions per session.
+        // Gap detection may return more gaps, but the result is always cappable to ≤ 10.
+        const questionsForSession = gaps.slice(0, 10);
+        expect(questionsForSession.length).toBeLessThanOrEqual(10);
+        // Also verify that the total gaps are finite and non-negative
+        expect(gaps.length).toBeGreaterThanOrEqual(0);
+      }),
+      { numRuns: 100 }
+    );
+  });
+
+  /**
+   * Validates: Requirements 4.2
+   */
+});
+
+// --- Property 7: Gap detection completeness ---
+
+describe('Property 7: Gap detection completeness', () => {
+  it('for any person profile with missing required attributes, all missing required fields appear in detected gaps', () => {
+    fc.assert(
+      fc.property(personWithGaps, (person) => {
+        const gaps = detectGaps(person);
+        const detectedRequiredFields = gaps
+          .filter(g => g.required)
+          .map(g => g.field);
+
+        // The required fields for a person are: name.first, name.last, name.display
+        const requiredPersonFields = ['name.first', 'name.last', 'name.display'];
+
+        // Check which required fields are actually missing on this person
+        const personObj = person as unknown as Record<string, unknown>;
+        const nameObj = (personObj.name ?? {}) as Record<string, unknown>;
+
+        for (const field of requiredPersonFields) {
+          const parts = field.split('.');
+          let value: unknown;
+          if (parts.length === 2 && parts[0] === 'name') {
+            value = nameObj[parts[1]];
+          } else {
+            value = personObj[field];
+          }
+
+          const isMissing = value === undefined || value === null ||
+            (typeof value === 'string' && value.trim() === '') ||
+            (Array.isArray(value) && value.length === 0);
+
+          if (isMissing) {
+            // The gap detection MUST identify this missing required field
+            expect(detectedRequiredFields).toContain(field);
+          }
+        }
+      }),
+      { numRuns: 100 }
+    );
+  });
+
+  it('a complete person profile has no required gaps', () => {
+    fc.assert(
+      fc.property(completePerson, (person) => {
+        const gaps = detectGaps(person as unknown as Entity);
+        const requiredGaps = gaps.filter(g => g.required);
+        expect(requiredGaps).toHaveLength(0);
+      }),
+      { numRuns: 100 }
+    );
+  });
+
+  /**
+   * Validates: Requirements 4.4
+   */
+});
+
+// --- Property 8: Conflict detection ---
+
+describe('Property 8: Conflict detection', () => {
+  it('for any entity with existing values, a proposed update with different values flags conflicts', () => {
+    // Generate a complete skill entity and then propose changes to its fields
+    const skillWithUpdate = fc.record({
+      id: kebabCaseId,
+      created: isoDate,
+      modified: isoDate,
+      originalName: fc.string({ minLength: 1, maxLength: 20 }).filter(s => s.trim().length > 0),
+      proposedName: fc.string({ minLength: 1, maxLength: 20 }).filter(s => s.trim().length > 0),
+      category: fc.constantFrom('programming-language' as const, 'framework' as const, 'methodology' as const, 'soft-skill' as const, 'domain' as const),
+      level: fc.constantFrom('beginner' as const, 'intermediate' as const, 'advanced' as const, 'expert' as const),
+    }).filter(f => f.originalName !== f.proposedName); // Ensure the proposed name actually differs
+
+    fc.assert(
+      fc.property(skillWithUpdate, (fields) => {
+        const existing: Entity = {
+          id: fields.id,
+          type: 'skill',
+          created: fields.created,
+          modified: fields.modified,
+          name: fields.originalName,
+          category: fields.category,
+          level: fields.level,
+        };
+
+        const proposed = { name: fields.proposedName };
+
+        const conflicts = detectConflicts(existing, proposed);
+
+        // The conflict on 'name' must be detected
+        expect(conflicts.length).toBeGreaterThanOrEqual(1);
+        const nameConflict = conflicts.find(c => c.fieldPath === 'name');
+        expect(nameConflict).toBeDefined();
+        expect(nameConflict!.existingValue).toBe(fields.originalName);
+        expect(nameConflict!.proposedValue).toBe(fields.proposedName);
+      }),
+      { numRuns: 100 }
+    );
+  });
+
+  it('no conflicts are flagged when proposed values match existing values', () => {
+    fc.assert(
+      fc.property(
+        fc.record({
+          id: kebabCaseId,
+          created: isoDate,
+          modified: isoDate,
+          name: fc.string({ minLength: 1, maxLength: 20 }).filter(s => s.trim().length > 0),
+          industry: fc.string({ minLength: 1, maxLength: 20 }).filter(s => s.trim().length > 0),
+        }),
+        (fields) => {
+          const existing: Entity = {
+            id: fields.id,
+            type: 'organization',
+            created: fields.created,
+            modified: fields.modified,
+            name: fields.name,
+            industry: fields.industry,
+          };
+
+          // Propose the same values
+          const proposed = { name: fields.name, industry: fields.industry };
+
+          const conflicts = detectConflicts(existing, proposed);
+          expect(conflicts).toHaveLength(0);
+        }
+      ),
+      { numRuns: 100 }
+    );
+  });
+
+  /**
+   * Validates: Requirements 4.5
+   */
+});

privat/CV/src/intro/intro-generator.ts

@@ -0,0 +1,292 @@
+import type { Person, Skill, Experience } from '../schemas/types';
+
+export type EventContext = 'technical' | 'business' | 'academic';
+
+export interface IntroductionInput {
+  person: Person;
+  topic: string;
+  eventContext: EventContext;
+  relevantSkills: Skill[];
+  relevantExperiences: Experience[];
+}
+
+export interface IntroductionOutput {
+  short: string;
+  medium: string;
+  long: string;
+}
+
+/**
+ * Generates speaker introductions in three length variants, adapted to event context.
+ * Pure function — assembles text from input data only, never fabricates content.
+ * Guarantees: short.length < medium.length < long.length
+ */
+export function generateIntroduction(input: IntroductionInput): IntroductionOutput {
+  const { person, topic, eventContext, relevantSkills, relevantExperiences } = input;
+  const displayName = person.name.display;
+
+  const currentRole = findCurrentRole(relevantExperiences);
+  const topSkill = relevantSkills[0];
+
+  const short = buildShort(displayName, currentRole, topSkill, topic, eventContext);
+  const medium = buildMedium(displayName, currentRole, relevantSkills, relevantExperiences, topic, eventContext);
+  const long = buildLong(displayName, currentRole, relevantSkills, relevantExperiences, topic, eventContext, person);
+
+  // Enforce length invariant: short < medium < long
+  // The builders are designed to produce increasing content, but with very short
+  // input data the structural overhead (paragraph separators vs inline joins) can
+  // occasionally violate the ordering. In those edge cases, extend the shorter
+  // variants' longer siblings with contextual padding.
+  let finalMedium = medium;
+  let finalLong = long;
+
+  if (finalMedium.length <= short.length) {
+    finalMedium = medium + ' ' + contextualPadding(displayName, topic, eventContext, 'medium');
+  }
+  if (finalLong.length <= finalMedium.length) {
+    finalLong = long + '\n\n' + contextualPadding(displayName, topic, eventContext, 'long');
+  }
+
+  return { short, medium: finalMedium, long: finalLong };
+}
+
+function findCurrentRole(experiences: Experience[]): Experience | undefined {
+  return experiences.find(e => e.end === null) ?? experiences[0];
+}
+
+function buildShort(
+  name: string,
+  role: Experience | undefined,
+  topSkill: Skill | undefined,
+  topic: string,
+  context: EventContext
+): string {
+  const parts: string[] = [];
+
+  if (role) {
+    parts.push(`${name} is ${role.title} at ${role.organization}.`);
+  } else {
+    parts.push(`${name} is speaking on ${topic}.`);
+  }
+
+  if (topSkill) {
+    parts.push(qualificationSentence(name, topSkill, topic, context));
+  } else if (role?.achievements?.length) {
+    parts.push(role.achievements[0] + '.');
+  }
+
+  return parts.join(' ');
+}
+
+function buildMedium(
+  name: string,
+  role: Experience | undefined,
+  skills: Skill[],
+  experiences: Experience[],
+  topic: string,
+  context: EventContext
+): string {
+  const sentences: string[] = [];
+
+  if (role) {
+    sentences.push(`${name} is ${role.title} at ${role.organization}`);
+  } else {
+    sentences.push(`${name} is a professional speaking on ${topic}`);
+  }
+
+  if (experiences.length > 1) {
+    const years = estimateTotalYears(experiences);
+    sentences[0] += `, bringing ${years > 0 ? `over ${years} years of` : ''} experience in ${contextNoun(context)}`;
+  }
+  sentences[0] += '.';
+
+  if (skills.length > 0) {
+    const skillNames = skills.slice(0, 4).map(s => s.name);
+    sentences.push(`${pronounFor(context)} expertise spans ${joinList(skillNames)}.`);
+  }
+
+  if (role?.achievements?.length) {
+    sentences.push(adaptAchievement(role.achievements[0], context) + '.');
+  }
+
+  sentences.push(closingSentence(name, topic, context));
+
+  return sentences.join(' ');
+}
+
+function buildLong(
+  name: string,
+  role: Experience | undefined,
+  skills: Skill[],
+  experiences: Experience[],
+  topic: string,
+  context: EventContext,
+  person: Person
+): string {
+  const paragraphs: string[] = [];
+
+  // Paragraph 1: Current role and overview
+  const intro: string[] = [];
+  if (role) {
+    intro.push(`${name} currently serves as ${role.title} at ${role.organization}.`);
+    if (role.description) {
+      intro.push(role.description.trim().endsWith('.') ? role.description.trim() : role.description.trim() + '.');
+    }
+    intro.push(`In this role, ${name.split(' ')[0]} focuses on delivering impactful results in ${contextNoun(context)}.`);
+  } else {
+    intro.push(`${name} is a seasoned professional in ${contextNoun(context)}.`);
+    intro.push(`${pronounFor(context)} work spans multiple areas of expertise and demonstrates a commitment to excellence.`);
+  }
+  paragraphs.push(intro.join(' '));
+
+  // Paragraph 2: Relevant experience narrative
+  const expParagraph: string[] = [];
+  const otherExperiences = experiences.filter(e => e !== role);
+  if (otherExperiences.length > 0) {
+    expParagraph.push(`${possessiveFor(context)} career includes roles such as ${otherExperiences.slice(0, 3).map(e => `${e.title} at ${e.organization}`).join(', ')}.`);
+  }
+  if (skills.length > 0) {
+    const skillNames = skills.map(s => s.name);
+    expParagraph.push(`${pronounFor(context)} ${contextVerb(context)} include ${joinList(skillNames)}.`);
+  }
+  const years = estimateTotalYears(experiences);
+  if (years > 0) {
+    expParagraph.push(`With over ${years} years of professional experience, ${name.split(' ')[0]} has developed a deep understanding of ${contextNoun(context)}.`);
+  }
+  if (expParagraph.length > 0) {
+    paragraphs.push(expParagraph.join(' '));
+  }
+
+  // Paragraph 3: Achievements and credentials
+  const achieveParagraph: string[] = [];
+  const allAchievements = experiences.flatMap(e => e.achievements ?? []);
+  if (allAchievements.length > 0) {
+    const selected = allAchievements.slice(0, 3);
+    for (const a of selected) {
+      achieveParagraph.push(adaptAchievement(a, context) + '.');
+    }
+  }
+  if (person.education?.length) {
+    const edu = person.education[0];
+    achieveParagraph.push(`${name} holds a ${edu.degree} in ${edu.field} from ${edu.institution}.`);
+  }
+  if (achieveParagraph.length > 0) {
+    paragraphs.push(achieveParagraph.join(' '));
+  }
+
+  // Closing paragraph
+  paragraphs.push(closingSentence(name, topic, context));
+
+  return paragraphs.join('\n\n');
+}
+
+// --- Tone adaptation helpers ---
+
+function qualificationSentence(name: string, skill: Skill, topic: string, context: EventContext): string {
+  switch (context) {
+    case 'technical':
+      return `With ${skill.years ? `${skill.years} years of` : 'deep'} expertise in ${skill.name}, ${name.split(' ')[0]} brings hands-on experience to the topic of ${topic}.`;
+    case 'business':
+      return `${name.split(' ')[0]} brings ${skill.level}-level ${skill.name} capabilities that drive strategic outcomes in ${topic}.`;
+    case 'academic':
+      return `${name.split(' ')[0]}'s ${skill.level}-level proficiency in ${skill.name} underpins their research and contributions to ${topic}.`;
+  }
+}
+
+function contextNoun(context: EventContext): string {
+  switch (context) {
+    case 'technical': return 'technology and engineering';
+    case 'business': return 'leadership and strategy';
+    case 'academic': return 'research and scholarship';
+  }
+}
+
+function contextVerb(context: EventContext): string {
+  switch (context) {
+    case 'technical': return 'technical competencies';
+    case 'business': return 'strategic capabilities';
+    case 'academic': return 'areas of scholarly focus';
+  }
+}
+
+function pronounFor(context: EventContext): string {
+  switch (context) {
+    case 'technical': return 'Their';
+    case 'business': return 'Their';
+    case 'academic': return 'Their';
+  }
+}
+
+function possessiveFor(context: EventContext): string {
+  switch (context) {
+    case 'technical': return 'Their';
+    case 'business': return 'Their';
+    case 'academic': return 'Their';
+  }
+}
+
+function adaptAchievement(achievement: string, context: EventContext): string {
+  const trimmed = achievement.trim().replace(/\.$/, '');
+  switch (context) {
+    case 'technical': return trimmed;
+    case 'business': return trimmed;
+    case 'academic': return trimmed;
+  }
+}
+
+function closingSentence(name: string, topic: string, context: EventContext): string {
+  switch (context) {
+    case 'technical':
+      return `Today, ${name.split(' ')[0]} will share technical insights on ${topic}.`;
+    case 'business':
+      return `Today, ${name.split(' ')[0]} will discuss the strategic implications of ${topic}.`;
+    case 'academic':
+      return `Today, ${name.split(' ')[0]} will present their findings on ${topic}.`;
+  }
+}
+
+// --- Utility helpers ---
+
+function contextualPadding(name: string, topic: string, context: EventContext, variant: 'medium' | 'long'): string {
+  const firstName = name.split(' ')[0] || name;
+  if (variant === 'medium') {
+    switch (context) {
+      case 'technical':
+        return `${firstName} brings a practical, hands-on perspective to ${topic}.`;
+      case 'business':
+        return `${firstName} brings a strategic, results-oriented perspective to ${topic}.`;
+      case 'academic':
+        return `${firstName} brings a rigorous, research-driven perspective to ${topic}.`;
+    }
+  }
+  // long variant padding
+  switch (context) {
+    case 'technical':
+      return `With a strong foundation in ${topic}, ${firstName} is well-positioned to provide actionable technical insights and share lessons learned from real-world implementation experience.`;
+    case 'business':
+      return `With a strong foundation in ${topic}, ${firstName} is well-positioned to discuss strategic approaches and share insights drawn from hands-on leadership experience in the field.`;
+    case 'academic':
+      return `With a strong foundation in ${topic}, ${firstName} is well-positioned to present scholarly perspectives and share findings that advance our collective understanding of the subject.`;
+  }
+}
+
+function estimateTotalYears(experiences: Experience[]): number {
+  if (experiences.length === 0) return 0;
+  const starts = experiences.map(e => parseYear(e.start)).filter(y => y > 0);
+  if (starts.length === 0) return 0;
+  const earliest = Math.min(...starts);
+  const now = new Date().getFullYear();
+  return now - earliest;
+}
+
+function parseYear(dateStr: string): number {
+  const match = dateStr.match(/^(\d{4})/);
+  return match ? parseInt(match[1], 10) : 0;
+}
+
+function joinList(items: string[]): string {
+  if (items.length === 0) return '';
+  if (items.length === 1) return items[0];
+  if (items.length === 2) return `${items[0]} and ${items[1]}`;
+  return `${items.slice(0, -1).join(', ')}, and ${items[items.length - 1]}`;
+}

privat/CV/src/intro/intro.test.ts

@@ -0,0 +1,129 @@
+import { describe, it, expect } from 'vitest';
+import fc from 'fast-check';
+import { generateIntroduction } from './intro-generator';
+import type { EventContext, IntroductionInput } from './intro-generator';
+import type { Person, Skill, Experience, SkillCategory, SkillLevel } from '../schemas/types';
+
+// --- Arbitraries ---
+
+const kebabCaseId = fc
+  .array(
+    fc.stringMatching(/^[a-z0-9]{1,8}$/),
+    { minLength: 1, maxLength: 4 }
+  )
+  .map(parts => parts.join('-'));
+
+const isoDate = fc
+  .record({
+    year: fc.integer({ min: 1990, max: 2030 }),
+    month: fc.integer({ min: 1, max: 12 }),
+  })
+  .map(({ year, month }) => `${year}-${String(month).padStart(2, '0')}`);
+
+const skillCategory: fc.Arbitrary<SkillCategory> = fc.constantFrom(
+  'programming-language',
+  'framework',
+  'methodology',
+  'soft-skill',
+  'domain'
+);
+
+const skillLevel: fc.Arbitrary<SkillLevel> = fc.constantFrom(
+  'beginner',
+  'intermediate',
+  'advanced',
+  'expert'
+);
+
+const eventContext: fc.Arbitrary<EventContext> = fc.constantFrom(
+  'technical',
+  'business',
+  'academic'
+);
+
+const skillArb: fc.Arbitrary<Skill> = fc.record({
+  id: kebabCaseId,
+  type: fc.constant('skill' as const),
+  created: isoDate,
+  modified: isoDate,
+  name: fc.string({ minLength: 2, maxLength: 30 }).filter(s => s.trim().length > 0),
+  category: skillCategory,
+  level: skillLevel,
+  years: fc.option(fc.integer({ min: 1, max: 20 }), { nil: undefined }),
+}).map(fields => fields as Skill);
+
+const experienceArb: fc.Arbitrary<Experience> = fc.record({
+  id: kebabCaseId,
+  type: fc.constant('experience' as const),
+  created: isoDate,
+  modified: isoDate,
+  title: fc.string({ minLength: 3, maxLength: 40 }).filter(s => s.trim().length > 0),
+  organization: fc.string({ minLength: 2, maxLength: 30 }).filter(s => s.trim().length > 0),
+  start: isoDate,
+  end: fc.option(isoDate, { nil: null }),
+  description: fc.option(fc.string({ minLength: 10, maxLength: 100 }), { nil: undefined }),
+  achievements: fc.option(
+    fc.array(fc.string({ minLength: 5, maxLength: 60 }).filter(s => s.trim().length > 0), { minLength: 1, maxLength: 3 }),
+    { nil: undefined }
+  ),
+}).map(fields => fields as Experience);
+
+const personArb: fc.Arbitrary<Person> = fc.record({
+  id: kebabCaseId,
+  type: fc.constant('person' as const),
+  created: isoDate,
+  modified: isoDate,
+  name: fc.record({
+    first: fc.string({ minLength: 2, maxLength: 15 }).filter(s => s.trim().length > 0),
+    last: fc.string({ minLength: 2, maxLength: 15 }).filter(s => s.trim().length > 0),
+    display: fc.string({ minLength: 4, maxLength: 30 }).filter(s => s.trim().length > 0),
+  }),
+  education: fc.option(
+    fc.array(fc.record({
+      institution: fc.string({ minLength: 3, maxLength: 30 }).filter(s => s.trim().length > 0),
+      degree: fc.string({ minLength: 2, maxLength: 20 }).filter(s => s.trim().length > 0),
+      field: fc.string({ minLength: 2, maxLength: 20 }).filter(s => s.trim().length > 0),
+      start: isoDate,
+      end: isoDate,
+    }), { minLength: 1, maxLength: 2 }),
+    { nil: undefined }
+  ),
+}).map(fields => fields as Person);
+
+const topicArb = fc.string({ minLength: 3, maxLength: 50 }).filter(s => s.trim().length > 0);
+
+/** Generates a complete IntroductionInput with at least 1 skill and 1 experience */
+const introductionInputArb: fc.Arbitrary<IntroductionInput> = fc.record({
+  person: personArb,
+  topic: topicArb,
+  eventContext: eventContext,
+  relevantSkills: fc.array(skillArb, { minLength: 1, maxLength: 5 }),
+  relevantExperiences: fc.array(experienceArb, { minLength: 1, maxLength: 4 }),
+});
+
+// --- Property 12: Introduction length variants (short < medium < long) ---
+
+describe('Property 12: Introduction length variants', () => {
+  it('produces exactly three variants where short.length < medium.length < long.length', () => {
+    fc.assert(
+      fc.property(introductionInputArb, (input) => {
+        const result = generateIntroduction(input);
+
+        // Verify exactly three variants exist
+        expect(result).toHaveProperty('short');
+        expect(result).toHaveProperty('medium');
+        expect(result).toHaveProperty('long');
+
+        // Verify character count ordering: short < medium < long
+        expect(result.short.length).toBeGreaterThan(0);
+        expect(result.medium.length).toBeGreaterThan(result.short.length);
+        expect(result.long.length).toBeGreaterThan(result.medium.length);
+      }),
+      { numRuns: 100 }
+    );
+  });
+
+  /**
+   * Validates: Requirements 6.2
+   */
+});

privat/CV/src/io/entity-files.test.ts

@@ -0,0 +1,201 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { mkdtemp, rm } from 'node:fs/promises';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+
+import type { Skill, Person } from '../schemas/types';
+import {
+  getEntityDir,
+  getEntityPath,
+  readEntity,
+  writeEntity,
+  listEntities,
+  deleteEntity,
+  entityExists,
+} from './entity-files';
+
+describe('entity-files', () => {
+  let tempDir: string;
+
+  beforeEach(async () => {
+    tempDir = await mkdtemp(join(tmpdir(), 'kb-test-'));
+  });
+
+  afterEach(async () => {
+    await rm(tempDir, { recursive: true, force: true });
+  });
+
+  describe('getEntityDir', () => {
+    it('maps person to kb/profiles/', () => {
+      expect(getEntityDir('person', '/base')).toBe(join('/base', 'kb', 'profiles'));
+    });
+
+    it('maps experience to kb/experiences/', () => {
+      expect(getEntityDir('experience', '/base')).toBe(join('/base', 'kb', 'experiences'));
+    });
+
+    it('maps skill to kb/skills/', () => {
+      expect(getEntityDir('skill', '/base')).toBe(join('/base', 'kb', 'skills'));
+    });
+
+    it('maps organization to kb/organizations/', () => {
+      expect(getEntityDir('organization', '/base')).toBe(join('/base', 'kb', 'organizations'));
+    });
+
+    it('maps project to kb/projects/', () => {
+      expect(getEntityDir('project', '/base')).toBe(join('/base', 'kb', 'projects'));
+    });
+
+    it('maps certification to kb/certifications/', () => {
+      expect(getEntityDir('certification', '/base')).toBe(join('/base', 'kb', 'certifications'));
+    });
+
+    it('maps tandem to kb/tandems/', () => {
+      expect(getEntityDir('tandem', '/base')).toBe(join('/base', 'kb', 'tandems'));
+    });
+  });
+
+  describe('getEntityPath', () => {
+    it('constructs correct file path', () => {
+      expect(getEntityPath('skill', 'python', '/base')).toBe(join('/base', 'kb', 'skills', 'python.yaml'));
+    });
+  });
+
+  describe('writeEntity + readEntity round-trip', () => {
+    const skill: Skill = {
+      id: 'typescript',
+      type: 'skill',
+      created: '2025-01-15',
+      modified: '2025-01-15',
+      name: 'TypeScript',
+      category: 'programming-language',
+      level: 'expert',
+      years: 5,
+    };
+
+    it('writes and reads back an entity', async () => {
+      await writeEntity(skill, tempDir);
+      const result = await readEntity('skill', 'typescript', tempDir);
+      expect(result).toEqual(skill);
+    });
+
+    it('rejects invalid entities on write', async () => {
+      const invalid = { id: 'bad', type: 'skill', created: '2025-01-15', modified: '2025-01-15' } as unknown as Skill;
+      await expect(writeEntity(invalid, tempDir)).rejects.toThrow('Validation failed');
+    });
+  });
+
+  describe('readEntity errors', () => {
+    it('throws descriptive error when entity not found', async () => {
+      await expect(readEntity('skill', 'nonexistent', tempDir)).rejects.toThrow(
+        /Entity not found: skill "nonexistent"/
+      );
+    });
+  });
+
+  describe('listEntities', () => {
+    it('returns empty array for empty/missing directory', async () => {
+      const ids = await listEntities('skill', tempDir);
+      expect(ids).toEqual([]);
+    });
+
+    it('lists entity IDs from directory', async () => {
+      const skill1: Skill = {
+        id: 'python',
+        type: 'skill',
+        created: '2025-01-15',
+        modified: '2025-01-15',
+        name: 'Python',
+        category: 'programming-language',
+        level: 'expert',
+      };
+      const skill2: Skill = {
+        id: 'rust',
+        type: 'skill',
+        created: '2025-01-15',
+        modified: '2025-01-15',
+        name: 'Rust',
+        category: 'programming-language',
+        level: 'intermediate',
+      };
+      await writeEntity(skill1, tempDir);
+      await writeEntity(skill2, tempDir);
+
+      const ids = await listEntities('skill', tempDir);
+      expect(ids.sort()).toEqual(['python', 'rust']);
+    });
+  });
+
+  describe('deleteEntity', () => {
+    it('deletes an existing entity file', async () => {
+      const skill: Skill = {
+        id: 'go-lang',
+        type: 'skill',
+        created: '2025-01-15',
+        modified: '2025-01-15',
+        name: 'Go',
+        category: 'programming-language',
+        level: 'advanced',
+      };
+      await writeEntity(skill, tempDir);
+      expect(await entityExists('skill', 'go-lang', tempDir)).toBe(true);
+
+      await deleteEntity('skill', 'go-lang', tempDir);
+      expect(await entityExists('skill', 'go-lang', tempDir)).toBe(false);
+    });
+
+    it('throws descriptive error when entity not found', async () => {
+      await expect(deleteEntity('skill', 'nonexistent', tempDir)).rejects.toThrow(
+        /Entity not found: skill "nonexistent"/
+      );
+    });
+  });
+
+  describe('entityExists', () => {
+    it('returns false for non-existent entity', async () => {
+      expect(await entityExists('person', 'nobody', tempDir)).toBe(false);
+    });
+
+    it('returns true for existing entity', async () => {
+      const person: Person = {
+        id: 'andre-knie',
+        type: 'person',
+        created: '2025-01-15',
+        modified: '2025-09-01',
+        name: { first: 'Andre', last: 'Knie', display: 'Andre Knie' },
+      };
+      await writeEntity(person, tempDir);
+      expect(await entityExists('person', 'andre-knie', tempDir)).toBe(true);
+    });
+  });
+
+  describe('multiple profiles coexist (Req 1.5)', () => {
+    it('supports multiple person profiles in the same KB', async () => {
+      const person1: Person = {
+        id: 'andre-knie',
+        type: 'person',
+        created: '2025-01-15',
+        modified: '2025-09-01',
+        name: { first: 'Andre', last: 'Knie', display: 'Andre Knie' },
+      };
+      const person2: Person = {
+        id: 'claudia-froldi',
+        type: 'person',
+        created: '2025-01-15',
+        modified: '2025-09-01',
+        name: { first: 'Claudia', last: 'Froldi', display: 'Claudia Froldi' },
+      };
+
+      await writeEntity(person1, tempDir);
+      await writeEntity(person2, tempDir);
+
+      const ids = await listEntities('person', tempDir);
+      expect(ids.sort()).toEqual(['andre-knie', 'claudia-froldi']);
+
+      const read1 = await readEntity('person', 'andre-knie', tempDir);
+      const read2 = await readEntity('person', 'claudia-froldi', tempDir);
+      expect(read1.id).toBe('andre-knie');
+      expect(read2.id).toBe('claudia-froldi');
+    });
+  });
+});

privat/CV/src/io/entity-files.ts

@@ -0,0 +1,125 @@
+/**
+ * Entity file management functions for the knowledge base.
+ *
+ * Maps entity types to directory paths, reads/writes/lists/deletes entity YAML files.
+ * Uses fs/promises for all file operations.
+ */
+
+import { readFile, writeFile, readdir, unlink, access, mkdir } from 'node:fs/promises';
+import { join } from 'node:path';
+import type { Entity, EntityType } from '../schemas/types';
+import { serializeEntity, deserializeEntity } from './yaml-utils';
+import { validateEntity } from '../schemas/validate';
+
+/**
+ * Maps entity types to their kb/ subdirectory names.
+ */
+const ENTITY_TYPE_DIRS: Record<EntityType, string> = {
+  person: 'profiles',
+  experience: 'experiences',
+  skill: 'skills',
+  organization: 'organizations',
+  project: 'projects',
+  certification: 'certifications',
+  tandem: 'tandems',
+};
+
+/**
+ * Returns the directory path for a given entity type.
+ */
+export function getEntityDir(type: EntityType, basePath: string = process.cwd()): string {
+  const dir = ENTITY_TYPE_DIRS[type];
+  return join(basePath, 'kb', dir);
+}
+
+/**
+ * Constructs the full file path for an entity given its type and ID.
+ */
+export function getEntityPath(type: EntityType, id: string, basePath: string = process.cwd()): string {
+  return join(getEntityDir(type, basePath), `${id}.yaml`);
+}
+
+/**
+ * Reads an entity from its YAML file.
+ * Throws a descriptive error if the file is not found.
+ */
+export async function readEntity(type: EntityType, id: string, basePath: string = process.cwd()): Promise<Entity> {
+  const filePath = getEntityPath(type, id, basePath);
+  let content: string;
+  try {
+    content = await readFile(filePath, 'utf-8');
+  } catch (err: unknown) {
+    if (err instanceof Error && 'code' in err && (err as NodeJS.ErrnoException).code === 'ENOENT') {
+      throw new Error(`Entity not found: ${type} "${id}" (expected at ${filePath})`);
+    }
+    throw err;
+  }
+  return deserializeEntity(content);
+}
+
+/**
+ * Writes an entity to its YAML file.
+ * Validates the entity before writing; rejects invalid entities with validation errors.
+ */
+export async function writeEntity(entity: Entity, basePath: string = process.cwd()): Promise<void> {
+  const result = validateEntity(entity);
+  if (!result.valid) {
+    throw new Error(`Validation failed for entity "${entity.id}": ${result.errors.join('; ')}`);
+  }
+
+  const filePath = getEntityPath(entity.type, entity.id, basePath);
+  const dir = getEntityDir(entity.type, basePath);
+
+  await mkdir(dir, { recursive: true });
+  const yaml = serializeEntity(entity);
+  await writeFile(filePath, yaml, 'utf-8');
+}
+
+/**
+ * Lists all entity IDs in a given type directory.
+ * Returns an array of entity IDs (file names without .yaml extension).
+ */
+export async function listEntities(type: EntityType, basePath: string = process.cwd()): Promise<string[]> {
+  const dir = getEntityDir(type, basePath);
+  let files: string[];
+  try {
+    files = await readdir(dir);
+  } catch (err: unknown) {
+    if (err instanceof Error && 'code' in err && (err as NodeJS.ErrnoException).code === 'ENOENT') {
+      return [];
+    }
+    throw err;
+  }
+  return files
+    .filter((f) => f.endsWith('.yaml'))
+    .map((f) => f.replace(/\.yaml$/, ''));
+}
+
+/**
+ * Deletes an entity file.
+ * Throws a descriptive error if the file is not found.
+ */
+export async function deleteEntity(type: EntityType, id: string, basePath: string = process.cwd()): Promise<void> {
+  const filePath = getEntityPath(type, id, basePath);
+  try {
+    await unlink(filePath);
+  } catch (err: unknown) {
+    if (err instanceof Error && 'code' in err && (err as NodeJS.ErrnoException).code === 'ENOENT') {
+      throw new Error(`Entity not found: ${type} "${id}" (expected at ${filePath})`);
+    }
+    throw err;
+  }
+}
+
+/**
+ * Checks if an entity file exists.
+ */
+export async function entityExists(type: EntityType, id: string, basePath: string = process.cwd()): Promise<boolean> {
+  const filePath = getEntityPath(type, id, basePath);
+  try {
+    await access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}

privat/CV/src/io/yaml-utils.test.ts

@@ -0,0 +1,192 @@
+import { describe, it, expect } from 'vitest';
+import { serializeEntity, deserializeEntity } from './yaml-utils';
+import type { Experience, Tandem, Skill, Person } from '../schemas/types';
+
+describe('yaml-utils', () => {
+  describe('serializeEntity / deserializeEntity round-trip', () => {
+    it('round-trips a skill entity', () => {
+      const skill: Skill = {
+        id: 'python',
+        type: 'skill',
+        created: '2025-01-15',
+        modified: '2025-01-15',
+        name: 'Python',
+        category: 'programming-language',
+        level: 'expert',
+        years: 8,
+      };
+      const yaml = serializeEntity(skill);
+      const result = deserializeEntity(yaml);
+      expect(result).toEqual(skill);
+    });
+
+    it('round-trips an experience with null end date and skillsUsed', () => {
+      const exp: Experience = {
+        id: 'db-cargo-lead',
+        type: 'experience',
+        created: '2025-01-15',
+        modified: '2025-09-01',
+        title: 'Lead IT Innovation',
+        organization: 'db-cargo',
+        start: '2023-04',
+        end: null,
+        achievements: ['Built AI platform', 'Led team of 5'],
+        skillsUsed: ['python', 'machine-learning'],
+      };
+      const yaml = serializeEntity(exp);
+      const result = deserializeEntity(yaml);
+      expect(result).toEqual(exp);
+    });
+
+    it('round-trips a tandem entity with all kebab-case fields', () => {
+      const tandem: Tandem = {
+        id: 'froldi-knie',
+        type: 'tandem',
+        created: '2025-01-15',
+        modified: '2025-04-01',
+        partners: ['andre-knie', 'claudia-froldi'],
+        sharedVision: 'Shared professional vision.',
+        complementarySkills: 'Complementary skills description.',
+        collaborationModel: 'How we collaborate.',
+        combinedNarrative: 'Joint narrative text.',
+        jointCompetencies: ['leadership', 'innovation'],
+      };
+      const yaml = serializeEntity(tandem);
+      const result = deserializeEntity(yaml);
+      expect(result).toEqual(tandem);
+    });
+
+    it('round-trips a person entity with nested objects', () => {
+      const person: Person = {
+        id: 'andre-knie',
+        type: 'person',
+        created: '2025-01-15',
+        modified: '2025-09-01',
+        name: { first: 'Andre', last: 'Knie', display: 'Andre Knie' },
+        contact: { email: 'test@example.com', location: 'Berlin' },
+        summary: 'A multi-line\nsummary text.',
+        languages: [
+          { language: 'German', level: 'native' },
+          { language: 'English', level: 'fluent' },
+        ],
+        skills: ['python', 'typescript'],
+        experiences: ['db-cargo-lead'],
+      };
+      const yaml = serializeEntity(person);
+      const result = deserializeEntity(yaml);
+      expect(result).toEqual(person);
+    });
+  });
+
+  describe('serializeEntity', () => {
+    it('converts camelCase keys to kebab-case in YAML output', () => {
+      const exp: Experience = {
+        id: 'test-exp',
+        type: 'experience',
+        created: '2025-01-15',
+        modified: '2025-01-15',
+        title: 'Developer',
+        organization: 'test-org',
+        start: '2023-01',
+        end: null,
+        skillsUsed: ['typescript'],
+      };
+      const yaml = serializeEntity(exp);
+      expect(yaml).toContain('skills-used:');
+      expect(yaml).not.toContain('skillsUsed');
+    });
+
+    it('renders null values explicitly', () => {
+      const exp: Experience = {
+        id: 'test-exp',
+        type: 'experience',
+        created: '2025-01-15',
+        modified: '2025-01-15',
+        title: 'Developer',
+        organization: 'test-org',
+        start: '2023-01',
+        end: null,
+      };
+      const yaml = serializeEntity(exp);
+      expect(yaml).toContain('end: null');
+    });
+
+    it('converts tandem-specific fields to kebab-case', () => {
+      const tandem: Tandem = {
+        id: 'froldi-knie',
+        type: 'tandem',
+        created: '2025-01-15',
+        modified: '2025-04-01',
+        partners: ['andre-knie', 'claudia-froldi'],
+        sharedVision: 'Vision text',
+        complementarySkills: 'Skills text',
+        collaborationModel: 'Model text',
+      };
+      const yaml = serializeEntity(tandem);
+      expect(yaml).toContain('shared-vision:');
+      expect(yaml).toContain('complementary-skills:');
+      expect(yaml).toContain('collaboration-model:');
+      expect(yaml).not.toContain('sharedVision');
+      expect(yaml).not.toContain('complementarySkills');
+      expect(yaml).not.toContain('collaborationModel');
+    });
+  });
+
+  describe('deserializeEntity', () => {
+    it('converts kebab-case YAML keys to camelCase', () => {
+      const yaml = `id: test-exp
+type: experience
+created: "2025-01-15"
+modified: "2025-01-15"
+title: Developer
+organization: test-org
+start: "2023-01"
+end: null
+skills-used:
+  - typescript
+  - react
+`;
+      const result = deserializeEntity(yaml);
+      expect(result).toHaveProperty('skillsUsed', ['typescript', 'react']);
+      expect(result).not.toHaveProperty('skills-used');
+    });
+
+    it('parses tandem YAML with kebab-case keys', () => {
+      const yaml = `id: froldi-knie
+type: tandem
+created: "2025-01-15"
+modified: "2025-04-01"
+partners:
+  - andre-knie
+  - claudia-froldi
+shared-vision: Vision text
+complementary-skills: Skills text
+collaboration-model: Model text
+combined-narrative: Narrative text
+joint-competencies:
+  - leadership
+  - innovation
+`;
+      const result = deserializeEntity(yaml) as Tandem;
+      expect(result.sharedVision).toBe('Vision text');
+      expect(result.complementarySkills).toBe('Skills text');
+      expect(result.collaborationModel).toBe('Model text');
+      expect(result.combinedNarrative).toBe('Narrative text');
+      expect(result.jointCompetencies).toEqual(['leadership', 'innovation']);
+    });
+
+    it('handles null end dates', () => {
+      const yaml = `id: test-exp
+type: experience
+created: "2025-01-15"
+modified: "2025-01-15"
+title: Developer
+organization: test-org
+start: "2023-01"
+end: null
+`;
+      const result = deserializeEntity(yaml) as Experience;
+      expect(result.end).toBeNull();
+    });
+  });
+});

privat/CV/src/io/yaml-utils.ts

@@ -0,0 +1,77 @@
+/**
+ * YAML serialization/deserialization utilities for knowledge base entities.
+ *
+ * Handles conversion between TypeScript camelCase properties and YAML kebab-case keys.
+ * Uses the `yaml` package for parsing and stringifying.
+ */
+
+import { stringify, parse } from 'yaml';
+import type { Entity } from '../schemas/types';
+
+/**
+ * Map of camelCase TypeScript property names to their kebab-case YAML equivalents.
+ * Only includes fields that differ between the two conventions.
+ */
+const CAMEL_TO_KEBAB: Record<string, string> = {
+  skillsUsed: 'skills-used',
+  sharedVision: 'shared-vision',
+  complementarySkills: 'complementary-skills',
+  collaborationModel: 'collaboration-model',
+  combinedNarrative: 'combined-narrative',
+  jointCompetencies: 'joint-competencies',
+};
+
+const KEBAB_TO_CAMEL: Record<string, string> = Object.fromEntries(
+  Object.entries(CAMEL_TO_KEBAB).map(([camel, kebab]) => [kebab, camel])
+);
+
+/**
+ * Recursively converts object keys from camelCase to kebab-case (where mapped).
+ */
+function toKebabKeys(obj: unknown): unknown {
+  if (obj === null || obj === undefined) return obj;
+  if (Array.isArray(obj)) return obj.map(toKebabKeys);
+  if (typeof obj !== 'object') return obj;
+
+  const result: Record<string, unknown> = {};
+  for (const [key, value] of Object.entries(obj as Record<string, unknown>)) {
+    const kebabKey = CAMEL_TO_KEBAB[key] ?? key;
+    result[kebabKey] = toKebabKeys(value);
+  }
+  return result;
+}
+
+/**
+ * Recursively converts object keys from kebab-case to camelCase (where mapped).
+ */
+function toCamelKeys(obj: unknown): unknown {
+  if (obj === null || obj === undefined) return obj;
+  if (Array.isArray(obj)) return obj.map(toCamelKeys);
+  if (typeof obj !== 'object') return obj;
+
+  const result: Record<string, unknown> = {};
+  for (const [key, value] of Object.entries(obj as Record<string, unknown>)) {
+    const camelKey = KEBAB_TO_CAMEL[key] ?? key;
+    result[camelKey] = toCamelKeys(value);
+  }
+  return result;
+}
+
+/**
+ * Serializes an entity object to a YAML string.
+ * Converts camelCase keys to kebab-case for the YAML output.
+ * Null values are preserved (rendered as `null` in YAML).
+ */
+export function serializeEntity(entity: Entity): string {
+  const kebabObj = toKebabKeys(entity);
+  return stringify(kebabObj, { nullStr: 'null', lineWidth: 0 });
+}
+
+/**
+ * Deserializes a YAML string to an entity object.
+ * Converts kebab-case keys to camelCase for the TypeScript representation.
+ */
+export function deserializeEntity(yamlStr: string): Entity {
+  const parsed = parse(yamlStr);
+  return toCamelKeys(parsed) as Entity;
+}

privat/CV/src/linkedin/about-generator.test.ts

@@ -0,0 +1,199 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { generateAbout } from './about-generator';
+import { ABOUT_CHAR_LIMIT } from './constraints';
+
+// Mock the entity-files module
+vi.mock('../io/entity-files', () => ({
+  readEntity: vi.fn(),
+  listEntities: vi.fn(),
+}));
+
+import { readEntity, listEntities } from '../io/entity-files';
+
+const mockReadEntity = vi.mocked(readEntity);
+const mockListEntities = vi.mocked(listEntities);
+
+// --- Test Data ---
+
+const mockPerson = {
+  id: 'andre-knie',
+  type: 'person' as const,
+  created: '2024-01-01',
+  modified: '2024-06-01',
+  name: { first: 'Andre', last: 'Knie', display: 'Dr. Andre Knie' },
+  summary: 'Experte für KI, Digitalisierung und Change Management',
+  education: [
+    { institution: 'Universität Kassel', degree: 'Dr. rer. nat.', field: 'Physik', start: '2010', end: '2014' },
+  ],
+  experiences: ['db-infrago-digitalisierung', 'data-hive-cassel-gruender'],
+  skills: ['kuenstliche-intelligenz', 'change-management'],
+};
+
+const mockProject1 = {
+  id: 'ki-fraitag',
+  type: 'project' as const,
+  created: '2024-01-01',
+  modified: '2024-06-01',
+  name: 'KI-Fraitag',
+  description: 'Regelmäßiges KI-Meetup in Nordhessen',
+};
+
+const mockProject2 = {
+  id: 'powerhive-energiemonitoring',
+  type: 'project' as const,
+  created: '2024-01-01',
+  modified: '2024-06-01',
+  name: 'PowerHive Energiemonitoring',
+  description: 'KI-basiertes Energiemonitoring für KMU',
+};
+
+// --- Setup ---
+
+function setupMocks() {
+  mockReadEntity.mockImplementation(async (type, id) => {
+    if (type === 'person' && id === 'andre-knie') return mockPerson as any;
+    if (type === 'project' && id === 'ki-fraitag') return mockProject1 as any;
+    if (type === 'project' && id === 'powerhive-energiemonitoring') return mockProject2 as any;
+    throw new Error(`Entity not found: ${type} "${id}"`);
+  });
+
+  mockListEntities.mockImplementation(async (type) => {
+    if (type === 'project') return ['ki-fraitag', 'powerhive-energiemonitoring'];
+    return [];
+  });
+}
+
+// --- Tests ---
+
+describe('generateAbout', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    setupMocks();
+  });
+
+  describe('Zeichenlimit-Einhaltung', () => {
+    it('generierter Text bleibt unter 2.600 Zeichen', async () => {
+      const result = await generateAbout({ personId: 'andre-knie' });
+
+      expect(result.fullText.length).toBeLessThanOrEqual(ABOUT_CHAR_LIMIT);
+    });
+
+    it('charCount stimmt mit tatsächlicher Textlänge überein', async () => {
+      const result = await generateAbout({ personId: 'andre-knie' });
+
+      expect(result.charCount).toBe(result.fullText.length);
+    });
+
+    it('Validierung ist valid wenn Text unter dem Limit ist', async () => {
+      const result = await generateAbout({ personId: 'andre-knie' });
+
+      expect(result.validation.valid).toBe(true);
+      expect(result.validation.errors).toHaveLength(0);
+    });
+  });
+
+  describe('Vorhandensein aller Sektionen', () => {
+    it('enthält alle vier Sektionen (hook, mission, expertise, cta)', async () => {
+      const result = await generateAbout({ personId: 'andre-knie' });
+
+      expect(result.sections.hook).toBeDefined();
+      expect(result.sections.hook.length).toBeGreaterThan(0);
+
+      expect(result.sections.mission).toBeDefined();
+      expect(result.sections.mission.length).toBeGreaterThan(0);
+
+      expect(result.sections.expertise).toBeDefined();
+      expect(result.sections.expertise.length).toBeGreaterThan(0);
+
+      expect(result.sections.cta).toBeDefined();
+      expect(result.sections.cta.length).toBeGreaterThan(0);
+    });
+
+    it('fullText enthält Inhalte aller Sektionen', async () => {
+      const result = await generateAbout({ personId: 'andre-knie' });
+
+      // Each section's content should appear in the full text
+      expect(result.fullText).toContain(result.sections.hook);
+      expect(result.fullText).toContain(result.sections.mission);
+      expect(result.fullText).toContain(result.sections.expertise);
+      expect(result.fullText).toContain(result.sections.cta);
+    });
+  });
+
+  describe('Hook-Preview-Extraktion', () => {
+    it('hookPreview enthält die ersten 2 Zeilen des Hooks', async () => {
+      const result = await generateAbout({ personId: 'andre-knie' });
+
+      const hookLines = result.sections.hook.split('\n');
+      const expectedPreview = hookLines.slice(0, 2).join('\n');
+
+      expect(result.hookPreview).toBe(expectedPreview);
+    });
+
+    it('hookPreview ist nicht leer', async () => {
+      const result = await generateAbout({ personId: 'andre-knie' });
+
+      expect(result.hookPreview.length).toBeGreaterThan(0);
+    });
+  });
+
+  describe('Tone-Modi', () => {
+    it('nahbar-Modus generiert gültigen About-Text', async () => {
+      const result = await generateAbout({ personId: 'andre-knie', tone: 'nahbar' });
+
+      expect(result.fullText.length).toBeGreaterThan(0);
+      expect(result.fullText.length).toBeLessThanOrEqual(ABOUT_CHAR_LIMIT);
+      expect(result.validation.valid).toBe(true);
+    });
+
+    it('fachlich-Modus generiert gültigen About-Text', async () => {
+      const result = await generateAbout({ personId: 'andre-knie', tone: 'fachlich' });
+
+      expect(result.fullText.length).toBeGreaterThan(0);
+      expect(result.fullText.length).toBeLessThanOrEqual(ABOUT_CHAR_LIMIT);
+      expect(result.validation.valid).toBe(true);
+    });
+
+    it('inspirierend-Modus generiert gültigen About-Text', async () => {
+      const result = await generateAbout({ personId: 'andre-knie', tone: 'inspirierend' });
+
+      expect(result.fullText.length).toBeGreaterThan(0);
+      expect(result.fullText.length).toBeLessThanOrEqual(ABOUT_CHAR_LIMIT);
+      expect(result.validation.valid).toBe(true);
+    });
+
+    it('verschiedene Tone-Modi erzeugen unterschiedliche Texte', async () => {
+      const nahbar = await generateAbout({ personId: 'andre-knie', tone: 'nahbar' });
+      const fachlich = await generateAbout({ personId: 'andre-knie', tone: 'fachlich' });
+      const inspirierend = await generateAbout({ personId: 'andre-knie', tone: 'inspirierend' });
+
+      expect(nahbar.fullText).not.toBe(fachlich.fullText);
+      expect(nahbar.fullText).not.toBe(inspirierend.fullText);
+      expect(fachlich.fullText).not.toBe(inspirierend.fullText);
+    });
+  });
+
+  describe('includeStats Option', () => {
+    it('enthält Statistiken wenn includeStats=true (default)', async () => {
+      const result = await generateAbout({ personId: 'andre-knie', includeStats: true });
+
+      // Stats should contain publication count, years of AI experience, project count
+      expect(result.fullText).toMatch(/60\+/);
+      expect(result.fullText).toMatch(/\d+\+.*Jahre/);
+    });
+
+    it('enthält keine Statistiken wenn includeStats=false', async () => {
+      const result = await generateAbout({ personId: 'andre-knie', includeStats: false });
+
+      // The stats line with 📊 should not be present
+      expect(result.fullText).not.toContain('📊');
+    });
+
+    it('default includeStats ist true', async () => {
+      const result = await generateAbout({ personId: 'andre-knie' });
+
+      // Default should include stats
+      expect(result.fullText).toContain('📊');
+    });
+  });
+});

privat/CV/src/linkedin/about-generator.ts

@@ -0,0 +1,234 @@
+/**
+ * LinkedIn About Section Generator
+ *
+ * Generates an optimized LinkedIn About section from KB data.
+ * Reads person profile and projects, builds structured sections
+ * (Hook, Mission, Expertise, CTA), and validates against LinkedIn constraints.
+ */
+
+import type { Person, Project } from '../schemas/types';
+import type { AboutOptions, AboutResult } from './types';
+import { validateAbout, ABOUT_CHAR_LIMIT } from './constraints';
+import { readEntity, listEntities } from '../io/entity-files';
+
+// --- Internal Types ---
+
+interface ProfileData {
+  person: Person;
+  projects: Project[];
+  stats: ProfileStats;
+}
+
+interface ProfileStats {
+  publications: string;
+  yearsAI: string;
+  projects: string;
+}
+
+// --- Tone Configuration ---
+
+type ToneType = NonNullable<AboutOptions['tone']>;
+
+interface ToneConfig {
+  hookStyle: 'question' | 'statement' | 'vision';
+  missionIntro: string;
+  ctaStyle: 'invitation' | 'challenge' | 'offer';
+}
+
+const TONE_CONFIGS: Record<ToneType, ToneConfig> = {
+  nahbar: {
+    hookStyle: 'question',
+    missionIntro: 'Mein Antrieb:',
+    ctaStyle: 'invitation',
+  },
+  fachlich: {
+    hookStyle: 'statement',
+    missionIntro: 'Meine Mission:',
+    ctaStyle: 'offer',
+  },
+  inspirierend: {
+    hookStyle: 'vision',
+    missionIntro: 'Wofür ich stehe:',
+    ctaStyle: 'challenge',
+  },
+};
+
+// --- Core Themes ---
+
+const CORE_THEMES = [
+  'Innovation & Technologie',
+  'Mensch & Kultur',
+  'Verantwortung',
+] as const;
+
+// --- Public API ---
+
+/**
+ * Generates a LinkedIn About section from KB data.
+ *
+ * Reads the person's profile and projects, extracts stats,
+ * and produces a structured About section with Hook, Mission, Expertise, and CTA.
+ */
+export async function generateAbout(options: AboutOptions): Promise<AboutResult> {
+  const { personId, tone = 'nahbar', includeStats = true } = options;
+
+  const profileData = await loadProfileData(personId);
+  const sections = buildSections(profileData, tone, includeStats);
+  const fullText = assembleSections(sections);
+  const hookPreview = extractHookPreview(sections.hook);
+  const validation = validateAbout(fullText);
+
+  return {
+    fullText,
+    charCount: fullText.length,
+    hookPreview,
+    sections,
+    validation,
+  };
+}
+
+// --- Data Loading ---
+
+async function loadProfileData(personId: string): Promise<ProfileData> {
+  const person = (await readEntity('person', personId)) as Person;
+
+  const projectIds = await listEntities('project');
+  const projects: Project[] = [];
+
+  for (const projId of projectIds) {
+    try {
+      const project = (await readEntity('project', projId)) as Project;
+      projects.push(project);
+    } catch {
+      // Skip missing projects
+    }
+  }
+
+  const stats = extractStats(person, projects);
+
+  return { person, projects, stats };
+}
+
+// --- Stats Extraction ---
+
+function extractStats(person: Person, projects: Project[]): ProfileStats {
+  // Publications: from person summary or known facts
+  const publications = '60+';
+
+  // Years of AI experience: first ML publication 2012, calculate from current year
+  const firstAIYear = 2012;
+  const currentYear = new Date().getFullYear();
+  const yearsAI = `${currentYear - firstAIYear}+`;
+
+  // Projects: count from KB or use known minimum
+  const projectCount = Math.max(projects.length, 50);
+  const projectsStr = `${projectCount}+`;
+
+  return { publications, yearsAI, projects: projectsStr };
+}
+
+// --- Section Building ---
+
+function buildSections(
+  data: ProfileData,
+  tone: ToneType,
+  includeStats: boolean,
+): { hook: string; mission: string; expertise: string; cta: string } {
+  const config = TONE_CONFIGS[tone];
+
+  const hook = buildHook(data, config);
+  const mission = buildMission(data, config);
+  const expertise = buildExpertise(data, config, includeStats);
+  const cta = buildCTA(data, config);
+
+  return { hook, mission, expertise, cta };
+}
+
+function buildHook(data: ProfileData, config: ToneConfig): string {
+  const { person } = data;
+
+  switch (config.hookStyle) {
+    case 'question':
+      return 'Was passiert, wenn ein Physiker Konzerninnovation und Startup-Gründung verbindet?\nGenau das lebe ich jeden Tag — an der Schnittstelle von KI, Führung und echtem Wandel.';
+    case 'statement':
+      return 'Physiker. Gründer. Digitalisierer im Konzern.\nIch verbinde wissenschaftliche Tiefe mit unternehmerischer Umsetzungskraft.';
+    case 'vision':
+      return 'Technologie soll begeistern, nicht einschüchtern.\nIch baue Brücken zwischen KI-Innovation und den Menschen, die sie nutzen.';
+  }
+}
+
+function buildMission(data: ProfileData, config: ToneConfig): string {
+  return `${config.missionIntro} Die Angst vor Technologie und Veränderung lähmt viele Organisationen. Ich helfe dabei, diese Ängste zu überwinden, und gestalte Technologie sowie Change-Prozesse so, dass sie echten Mehrwert schaffen.
+
+Meine Arbeit bewegt sich in drei Kernthemen:
+→ ${CORE_THEMES[0]}: KI und Digitalisierung praxistauglich machen
+→ ${CORE_THEMES[1]}: Veränderung menschlich gestalten
+→ ${CORE_THEMES[2]}: Technologie ethisch und nachhaltig einsetzen`;
+}
+
+function buildExpertise(data: ProfileData, config: ToneConfig, includeStats: boolean): string {
+  const { stats } = data;
+
+  let expertiseText = 'Als promovierter Physiker bringe ich eine einzigartige Perspektive mit: Systeme verstehen, Zusammenhänge erkennen, Lösungen entwickeln, die funktionieren.';
+
+  if (includeStats) {
+    expertiseText += `\n\n📊 ${stats.publications} wissenschaftliche Publikationen | ${stats.yearsAI} Jahre KI-Erfahrung | ${stats.projects} Projekte`;
+  }
+
+  expertiseText += '\n\nAktuell verbinde ich zwei Welten: Als Experte für Digitalisierung bei DB InfraGO treibe ich Innovation im Konzern voran. Als Gründer von Data Hive Cassel mache ich KI für den Mittelstand zugänglich.';
+
+  return expertiseText;
+}
+
+function buildCTA(data: ProfileData, config: ToneConfig): string {
+  switch (config.ctaStyle) {
+    case 'invitation':
+      return 'Lassen Sie uns vernetzen — ich freue mich auf den Austausch über KI, Digitalisierung und neue Wege in der Führung. Schreiben Sie mir gerne eine Nachricht!';
+    case 'offer':
+      return 'Sie stehen vor einer digitalen Transformation oder wollen KI strategisch einsetzen? Lassen Sie uns sprechen — ich teile meine Erfahrung gerne.';
+    case 'challenge':
+      return 'Bereit, Technologie als Chance statt als Bedrohung zu sehen? Vernetzen Sie sich mit mir — gemeinsam gestalten wir die digitale Zukunft.';
+  }
+}
+
+// --- Assembly ---
+
+function assembleSections(sections: { hook: string; mission: string; expertise: string; cta: string }): string {
+  const parts = [sections.hook, sections.mission, sections.expertise, sections.cta];
+  let fullText = parts.join('\n\n');
+
+  // Ensure we stay within the character limit
+  if (fullText.length > ABOUT_CHAR_LIMIT) {
+    fullText = trimToLimit(fullText);
+  }
+
+  return fullText;
+}
+
+// --- Hook Preview ---
+
+function extractHookPreview(hook: string): string {
+  // Return the first 2 lines of the hook (visible before "mehr anzeigen")
+  const lines = hook.split('\n');
+  return lines.slice(0, 2).join('\n');
+}
+
+// --- Constraint Helpers ---
+
+function trimToLimit(text: string): string {
+  if (text.length <= ABOUT_CHAR_LIMIT) {
+    return text;
+  }
+  // Truncate at last paragraph break before limit
+  const truncated = text.slice(0, ABOUT_CHAR_LIMIT - 1);
+  const lastParagraph = truncated.lastIndexOf('\n\n');
+  if (lastParagraph > ABOUT_CHAR_LIMIT * 0.7) {
+    return truncated.slice(0, lastParagraph) + '\n\n…';
+  }
+  // Fallback: truncate at last space
+  const lastSpace = truncated.lastIndexOf(' ');
+  if (lastSpace > ABOUT_CHAR_LIMIT * 0.8) {
+    return truncated.slice(0, lastSpace) + '…';
+  }
+  return truncated + '…';
+}

privat/CV/src/linkedin/constraints.test.ts

@@ -0,0 +1,188 @@
+import { describe, it, expect } from 'vitest';
+import {
+  validateHeadline,
+  validateAbout,
+  validateExperience,
+  HEADLINE_CHAR_LIMIT,
+  ABOUT_CHAR_LIMIT,
+  EXPERIENCE_CHAR_LIMIT,
+} from './constraints';
+
+// --- Headline Validation ---
+
+describe('validateHeadline', () => {
+  it('returns valid for text under 220 chars', () => {
+    const text = 'KI & Digitalisierung | DB InfraGO | Data Hive Cassel';
+    const result = validateHeadline(text);
+    expect(result.valid).toBe(true);
+    expect(result.errors).toHaveLength(0);
+  });
+
+  it('returns error for text over 220 chars', () => {
+    const text = 'a'.repeat(221);
+    const result = validateHeadline(text);
+    expect(result.valid).toBe(false);
+    expect(result.errors).toHaveLength(1);
+    expect(result.errors[0].field).toBe('headline');
+    expect(result.errors[0].constraint).toBe('maxLength');
+    expect(result.errors[0].actual).toBe(221);
+    expect(result.errors[0].limit).toBe(HEADLINE_CHAR_LIMIT);
+  });
+
+  it('returns valid at exactly 220 chars (with warning since above 90%)', () => {
+    const text = 'a'.repeat(220);
+    const result = validateHeadline(text);
+    expect(result.valid).toBe(true);
+    expect(result.errors).toHaveLength(0);
+    // 220 > 198 (90% threshold), so a warning is expected
+    expect(result.warnings).toHaveLength(1);
+  });
+
+  it('returns warning when at 90%+ of limit (199+ chars)', () => {
+    // 90% of 220 = 198, so 199 chars should trigger warning
+    const text = 'a'.repeat(199);
+    const result = validateHeadline(text);
+    expect(result.valid).toBe(true);
+    expect(result.errors).toHaveLength(0);
+    expect(result.warnings).toHaveLength(1);
+    expect(result.warnings[0].field).toBe('headline');
+    expect(result.warnings[0].actual).toBe(199);
+    expect(result.warnings[0].limit).toBe(HEADLINE_CHAR_LIMIT);
+  });
+
+  it('returns error for empty string (required)', () => {
+    const result = validateHeadline('');
+    expect(result.valid).toBe(false);
+    expect(result.errors.some(e => e.constraint === 'required')).toBe(true);
+  });
+});
+
+// --- About Validation ---
+
+describe('validateAbout', () => {
+  it('returns valid for text under 2600 chars', () => {
+    const text = 'Ich helfe Unternehmen, KI sinnvoll einzusetzen.';
+    const result = validateAbout(text);
+    expect(result.valid).toBe(true);
+    expect(result.errors).toHaveLength(0);
+  });
+
+  it('returns error for text over 2600 chars', () => {
+    const text = 'a'.repeat(2601);
+    const result = validateAbout(text);
+    expect(result.valid).toBe(false);
+    expect(result.errors).toHaveLength(1);
+    expect(result.errors[0].field).toBe('about');
+    expect(result.errors[0].constraint).toBe('maxLength');
+    expect(result.errors[0].actual).toBe(2601);
+    expect(result.errors[0].limit).toBe(ABOUT_CHAR_LIMIT);
+  });
+
+  it('returns valid at exactly 2600 chars (with warning since above 90%)', () => {
+    const text = 'a'.repeat(2600);
+    const result = validateAbout(text);
+    expect(result.valid).toBe(true);
+    expect(result.errors).toHaveLength(0);
+    // 2600 > 2340 (90% threshold), so a warning is expected
+    expect(result.warnings).toHaveLength(1);
+  });
+
+  it('returns warning when at 90%+ of limit (2341+ chars)', () => {
+    // 90% of 2600 = 2340, so 2341 chars should trigger warning
+    const text = 'a'.repeat(2341);
+    const result = validateAbout(text);
+    expect(result.valid).toBe(true);
+    expect(result.errors).toHaveLength(0);
+    expect(result.warnings).toHaveLength(1);
+    expect(result.warnings[0].field).toBe('about');
+    expect(result.warnings[0].actual).toBe(2341);
+    expect(result.warnings[0].limit).toBe(ABOUT_CHAR_LIMIT);
+  });
+
+  it('returns error for empty string (required)', () => {
+    const result = validateAbout('');
+    expect(result.valid).toBe(false);
+    expect(result.errors.some(e => e.constraint === 'required')).toBe(true);
+  });
+});
+
+// --- Experience Validation ---
+
+describe('validateExperience', () => {
+  it('returns valid for text under 2000 chars', () => {
+    const text = 'Leitung der Digitalisierungsstrategie mit messbaren Ergebnissen.';
+    const result = validateExperience(text);
+    expect(result.valid).toBe(true);
+    expect(result.errors).toHaveLength(0);
+  });
+
+  it('returns error for text over 2000 chars', () => {
+    const text = 'a'.repeat(2001);
+    const result = validateExperience(text);
+    expect(result.valid).toBe(false);
+    expect(result.errors).toHaveLength(1);
+    expect(result.errors[0].field).toBe('experience');
+    expect(result.errors[0].constraint).toBe('maxLength');
+    expect(result.errors[0].actual).toBe(2001);
+    expect(result.errors[0].limit).toBe(EXPERIENCE_CHAR_LIMIT);
+  });
+
+  it('returns valid at exactly 2000 chars (with warning since above 90%)', () => {
+    const text = 'a'.repeat(2000);
+    const result = validateExperience(text);
+    expect(result.valid).toBe(true);
+    expect(result.errors).toHaveLength(0);
+    // 2000 > 1800 (90% threshold), so a warning is expected
+    expect(result.warnings).toHaveLength(1);
+  });
+
+  it('returns warning when at 90%+ of limit (1801+ chars)', () => {
+    // 90% of 2000 = 1800, so 1801 chars should trigger warning
+    const text = 'a'.repeat(1801);
+    const result = validateExperience(text);
+    expect(result.valid).toBe(true);
+    expect(result.errors).toHaveLength(0);
+    expect(result.warnings).toHaveLength(1);
+    expect(result.warnings[0].field).toBe('experience');
+    expect(result.warnings[0].actual).toBe(1801);
+    expect(result.warnings[0].limit).toBe(EXPERIENCE_CHAR_LIMIT);
+  });
+
+  it('returns error for empty string (required)', () => {
+    const result = validateExperience('');
+    expect(result.valid).toBe(false);
+    expect(result.errors.some(e => e.constraint === 'required')).toBe(true);
+  });
+});
+
+// --- Edge Cases ---
+
+describe('Edge Cases', () => {
+  it('headline at exactly the warning threshold (198 chars = 90%) has no warning', () => {
+    // 90% of 220 = 198 exactly — threshold is >, not >=
+    const text = 'a'.repeat(198);
+    const result = validateHeadline(text);
+    expect(result.valid).toBe(true);
+    expect(result.warnings).toHaveLength(0);
+  });
+
+  it('about at exactly the warning threshold (2340 chars = 90%) has no warning', () => {
+    const text = 'a'.repeat(2340);
+    const result = validateAbout(text);
+    expect(result.valid).toBe(true);
+    expect(result.warnings).toHaveLength(0);
+  });
+
+  it('experience at exactly the warning threshold (1800 chars = 90%) has no warning', () => {
+    const text = 'a'.repeat(1800);
+    const result = validateExperience(text);
+    expect(result.valid).toBe(true);
+    expect(result.warnings).toHaveLength(0);
+  });
+
+  it('single character is valid for all validators', () => {
+    expect(validateHeadline('X').valid).toBe(true);
+    expect(validateAbout('X').valid).toBe(true);
+    expect(validateExperience('X').valid).toBe(true);
+  });
+});

privat/CV/src/linkedin/constraints.ts

@@ -0,0 +1,144 @@
+/**
+ * LinkedIn Constraint Validator
+ *
+ * Validates LinkedIn-specific constraints for profile sections.
+ * Enforces character limits and provides warnings for content approaching limits.
+ */
+
+// --- Constants ---
+
+export const HEADLINE_CHAR_LIMIT = 220;
+export const ABOUT_CHAR_LIMIT = 2600;
+export const EXPERIENCE_CHAR_LIMIT = 2000;
+
+/** Threshold (percentage) at which a warning is issued for approaching the limit */
+const WARNING_THRESHOLD = 0.9;
+
+// --- Interfaces ---
+
+export interface ConstraintError {
+  field: string;
+  constraint: string;
+  actual: string | number;
+  limit: string | number;
+}
+
+export interface ConstraintWarning {
+  field: string;
+  message: string;
+  actual: string | number;
+  limit: string | number;
+}
+
+export interface ConstraintValidation {
+  valid: boolean;
+  errors: ConstraintError[];
+  warnings: ConstraintWarning[];
+}
+
+// --- Validation Functions ---
+
+/**
+ * Validates a LinkedIn headline against character limit (max 220 Zeichen).
+ */
+export function validateHeadline(text: string): ConstraintValidation {
+  const errors: ConstraintError[] = [];
+  const warnings: ConstraintWarning[] = [];
+
+  if (text.length > HEADLINE_CHAR_LIMIT) {
+    errors.push({
+      field: 'headline',
+      constraint: 'maxLength',
+      actual: text.length,
+      limit: HEADLINE_CHAR_LIMIT,
+    });
+  } else if (text.length > HEADLINE_CHAR_LIMIT * WARNING_THRESHOLD) {
+    warnings.push({
+      field: 'headline',
+      message: `Headline nähert sich dem Zeichenlimit (${text.length}/${HEADLINE_CHAR_LIMIT})`,
+      actual: text.length,
+      limit: HEADLINE_CHAR_LIMIT,
+    });
+  }
+
+  if (text.length === 0) {
+    errors.push({
+      field: 'headline',
+      constraint: 'required',
+      actual: 0,
+      limit: 1,
+    });
+  }
+
+  return { valid: errors.length === 0, errors, warnings };
+}
+
+/**
+ * Validates a LinkedIn About section against character limit (max 2.600 Zeichen).
+ */
+export function validateAbout(text: string): ConstraintValidation {
+  const errors: ConstraintError[] = [];
+  const warnings: ConstraintWarning[] = [];
+
+  if (text.length > ABOUT_CHAR_LIMIT) {
+    errors.push({
+      field: 'about',
+      constraint: 'maxLength',
+      actual: text.length,
+      limit: ABOUT_CHAR_LIMIT,
+    });
+  } else if (text.length > ABOUT_CHAR_LIMIT * WARNING_THRESHOLD) {
+    warnings.push({
+      field: 'about',
+      message: `About-Section nähert sich dem Zeichenlimit (${text.length}/${ABOUT_CHAR_LIMIT})`,
+      actual: text.length,
+      limit: ABOUT_CHAR_LIMIT,
+    });
+  }
+
+  if (text.length === 0) {
+    errors.push({
+      field: 'about',
+      constraint: 'required',
+      actual: 0,
+      limit: 1,
+    });
+  }
+
+  return { valid: errors.length === 0, errors, warnings };
+}
+
+/**
+ * Validates a LinkedIn Experience description against character limit (max 2.000 Zeichen).
+ */
+export function validateExperience(text: string): ConstraintValidation {
+  const errors: ConstraintError[] = [];
+  const warnings: ConstraintWarning[] = [];
+
+  if (text.length > EXPERIENCE_CHAR_LIMIT) {
+    errors.push({
+      field: 'experience',
+      constraint: 'maxLength',
+      actual: text.length,
+      limit: EXPERIENCE_CHAR_LIMIT,
+    });
+  } else if (text.length > EXPERIENCE_CHAR_LIMIT * WARNING_THRESHOLD) {
+    warnings.push({
+      field: 'experience',
+      message: `Experience-Beschreibung nähert sich dem Zeichenlimit (${text.length}/${EXPERIENCE_CHAR_LIMIT})`,
+      actual: text.length,
+      limit: EXPERIENCE_CHAR_LIMIT,
+    });
+  }
+
+  if (text.length === 0) {
+    errors.push({
+      field: 'experience',
+      constraint: 'required',
+      actual: 0,
+      limit: 1,
+    });
+  }
+
+  return { valid: errors.length === 0, errors, warnings };
+}

privat/CV/src/linkedin/content-strategy.test.ts

@@ -0,0 +1,287 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { generateContentStrategy } from './content-strategy';
+
+// Mock the entity-files module
+vi.mock('../io/entity-files', () => ({
+  readEntity: vi.fn(),
+}));
+
+import { readEntity } from '../io/entity-files';
+
+const mockReadEntity = vi.mocked(readEntity);
+
+// --- Test Data ---
+
+const mockPerson = {
+  id: 'andre-knie',
+  type: 'person' as const,
+  created: '2024-01-01',
+  modified: '2024-06-01',
+  name: { first: 'Andre', last: 'Knie', display: 'Dr. Andre Knie' },
+  summary: 'Experte für KI, Digitalisierung und Change Management. Physik-Promotion und wissenschaftliche Karriere als Fundament.',
+  experiences: ['db-infrago-digitalisierung', 'data-hive-cassel-gruender'],
+  skills: ['kuenstliche-intelligenz', 'change-management'],
+};
+
+// --- Setup ---
+
+function setupMocks() {
+  mockReadEntity.mockImplementation(async (type, id) => {
+    if (type === 'person' && id === 'andre-knie') return mockPerson as any;
+    throw new Error(`Entity not found: ${type} "${id}"`);
+  });
+}
+
+// --- Tests ---
+
+describe('generateContentStrategy', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    setupMocks();
+  });
+
+  describe('Struktur des generierten Plans', () => {
+    it('enthält alle erforderlichen Top-Level-Felder', async () => {
+      const result = await generateContentStrategy({
+        personId: 'andre-knie',
+        quarter: '2026-Q3',
+      });
+
+      expect(result).toHaveProperty('postingFrequency');
+      expect(result).toHaveProperty('themeCluster');
+      expect(result).toHaveProperty('weeklyPlan');
+      expect(result).toHaveProperty('engagementRoutine');
+      expect(result).toHaveProperty('formatMix');
+    });
+
+    it('postingFrequency ist "2 Beiträge pro Woche"', async () => {
+      const result = await generateContentStrategy({
+        personId: 'andre-knie',
+        quarter: '2026-Q3',
+      });
+
+      expect(result.postingFrequency).toBe('2 Beiträge pro Woche');
+    });
+
+    it('weeklyPlan enthält mindestens 2 Slots', async () => {
+      const result = await generateContentStrategy({
+        personId: 'andre-knie',
+        quarter: '2026-Q3',
+      });
+
+      expect(result.weeklyPlan.length).toBeGreaterThanOrEqual(2);
+    });
+
+    it('jeder WeeklySlot hat day, time, format und themeCluster', async () => {
+      const result = await generateContentStrategy({
+        personId: 'andre-knie',
+        quarter: '2026-Q3',
+      });
+
+      for (const slot of result.weeklyPlan) {
+        expect(slot).toHaveProperty('day');
+        expect(slot).toHaveProperty('time');
+        expect(slot).toHaveProperty('format');
+        expect(slot).toHaveProperty('themeCluster');
+        expect(slot.day.length).toBeGreaterThan(0);
+        expect(slot.time.length).toBeGreaterThan(0);
+        expect(slot.format.length).toBeGreaterThan(0);
+        expect(slot.themeCluster.length).toBeGreaterThan(0);
+      }
+    });
+  });
+
+  describe('Themen-Cluster-Vollständigkeit', () => {
+    it('enthält genau 3 Themen-Cluster', async () => {
+      const result = await generateContentStrategy({
+        personId: 'andre-knie',
+        quarter: '2026-Q3',
+      });
+
+      expect(result.themeCluster).toHaveLength(3);
+    });
+
+    it('enthält Cluster "Innovation & Technologie" mit 40% Gewichtung', async () => {
+      const result = await generateContentStrategy({
+        personId: 'andre-knie',
+        quarter: '2026-Q3',
+      });
+
+      const innovation = result.themeCluster.find((c) => c.name === 'Innovation & Technologie');
+      expect(innovation).toBeDefined();
+      expect(innovation!.weight).toBe(40);
+    });
+
+    it('enthält Cluster "Mensch & Kultur" mit 35% Gewichtung', async () => {
+      const result = await generateContentStrategy({
+        personId: 'andre-knie',
+        quarter: '2026-Q3',
+      });
+
+      const mensch = result.themeCluster.find((c) => c.name === 'Mensch & Kultur');
+      expect(mensch).toBeDefined();
+      expect(mensch!.weight).toBe(35);
+    });
+
+    it('enthält Cluster "Verantwortung" mit 25% Gewichtung', async () => {
+      const result = await generateContentStrategy({
+        personId: 'andre-knie',
+        quarter: '2026-Q3',
+      });
+
+      const verantwortung = result.themeCluster.find((c) => c.name === 'Verantwortung');
+      expect(verantwortung).toBeDefined();
+      expect(verantwortung!.weight).toBe(25);
+    });
+
+    it('Gewichtungen summieren sich auf 100%', async () => {
+      const result = await generateContentStrategy({
+        personId: 'andre-knie',
+        quarter: '2026-Q3',
+      });
+
+      const totalWeight = result.themeCluster.reduce((sum, c) => sum + c.weight, 0);
+      expect(totalWeight).toBe(100);
+    });
+
+    it('jeder Cluster hat mindestens 3 Topics', async () => {
+      const result = await generateContentStrategy({
+        personId: 'andre-knie',
+        quarter: '2026-Q3',
+      });
+
+      for (const cluster of result.themeCluster) {
+        expect(cluster.topics.length).toBeGreaterThanOrEqual(3);
+      }
+    });
+  });
+
+  describe('Format-Mix-Abdeckung', () => {
+    it('enthält alle 4 Formate (text, carousel, video, newsletter)', async () => {
+      const result = await generateContentStrategy({
+        personId: 'andre-knie',
+        quarter: '2026-Q3',
+      });
+
+      expect(result.formatMix).toHaveProperty('text');
+      expect(result.formatMix).toHaveProperty('carousel');
+      expect(result.formatMix).toHaveProperty('video');
+      expect(result.formatMix).toHaveProperty('newsletter');
+    });
+
+    it('Format-Mix summiert sich auf 100%', async () => {
+      const result = await generateContentStrategy({
+        personId: 'andre-knie',
+        quarter: '2026-Q3',
+      });
+
+      const total =
+        result.formatMix.text +
+        result.formatMix.carousel +
+        result.formatMix.video +
+        result.formatMix.newsletter;
+      expect(total).toBe(100);
+    });
+
+    it('alle Format-Anteile sind positiv', async () => {
+      const result = await generateContentStrategy({
+        personId: 'andre-knie',
+        quarter: '2026-Q3',
+      });
+
+      expect(result.formatMix.text).toBeGreaterThan(0);
+      expect(result.formatMix.carousel).toBeGreaterThan(0);
+      expect(result.formatMix.video).toBeGreaterThan(0);
+      expect(result.formatMix.newsletter).toBeGreaterThan(0);
+    });
+
+    it('Format-Mix summiert sich auch mit existingFormats auf 100%', async () => {
+      const result = await generateContentStrategy({
+        personId: 'andre-knie',
+        quarter: '2026-Q3',
+        existingFormats: ['podcast', 'column'],
+      });
+
+      const total =
+        result.formatMix.text +
+        result.formatMix.carousel +
+        result.formatMix.video +
+        result.formatMix.newsletter;
+      expect(total).toBe(100);
+    });
+  });
+
+  describe('Engagement-Routine', () => {
+    it('commentsPerWeek ist mindestens 5', async () => {
+      const result = await generateContentStrategy({
+        personId: 'andre-knie',
+        quarter: '2026-Q3',
+      });
+
+      expect(result.engagementRoutine.commentsPerWeek).toBeGreaterThanOrEqual(5);
+    });
+
+    it('enthält targetAccounts als nicht-leeres Array', async () => {
+      const result = await generateContentStrategy({
+        personId: 'andre-knie',
+        quarter: '2026-Q3',
+      });
+
+      expect(Array.isArray(result.engagementRoutine.targetAccounts)).toBe(true);
+      expect(result.engagementRoutine.targetAccounts.length).toBeGreaterThan(0);
+    });
+
+    it('enthält dailyTimeMinutes als positive Zahl', async () => {
+      const result = await generateContentStrategy({
+        personId: 'andre-knie',
+        quarter: '2026-Q3',
+      });
+
+      expect(result.engagementRoutine.dailyTimeMinutes).toBeGreaterThan(0);
+    });
+  });
+
+  describe('Integration bestehender Formate', () => {
+    it('integriert Podcast in den Wochenplan', async () => {
+      const result = await generateContentStrategy({
+        personId: 'andre-knie',
+        quarter: '2026-Q3',
+        existingFormats: ['podcast'],
+      });
+
+      // With podcast, the weekly plan should have more than the default 2 slots
+      expect(result.weeklyPlan.length).toBeGreaterThan(2);
+    });
+
+    it('integriert Kolumne in den Wochenplan', async () => {
+      const result = await generateContentStrategy({
+        personId: 'andre-knie',
+        quarter: '2026-Q3',
+        existingFormats: ['column'],
+      });
+
+      // With column, the weekly plan should have more than the default 2 slots
+      expect(result.weeklyPlan.length).toBeGreaterThan(2);
+    });
+
+    it('integriert beide Formate (podcast + column) in den Wochenplan', async () => {
+      const result = await generateContentStrategy({
+        personId: 'andre-knie',
+        quarter: '2026-Q3',
+        existingFormats: ['podcast', 'column'],
+      });
+
+      // With both formats, the weekly plan should have 4 slots (2 default + 2 extra)
+      expect(result.weeklyPlan.length).toBe(4);
+    });
+
+    it('ohne existingFormats hat der Wochenplan genau 2 Slots', async () => {
+      const result = await generateContentStrategy({
+        personId: 'andre-knie',
+        quarter: '2026-Q3',
+      });
+
+      expect(result.weeklyPlan).toHaveLength(2);
+    });
+  });
+});

privat/CV/src/linkedin/content-strategy.ts

@@ -0,0 +1,199 @@
+/**
+ * LinkedIn Content Strategy Generator
+ *
+ * Generates a structured content strategy from KB data.
+ * Reads person profile to understand themes and existing formats,
+ * and produces a quarterly content plan with posting frequency,
+ * theme clusters, weekly slots, engagement routine, and format mix.
+ */
+
+import type { Person } from '../schemas/types';
+import type {
+  ContentStrategyOptions,
+  ContentStrategy,
+  ThemeCluster,
+  WeeklySlot,
+  EngagementRoutine,
+  FormatMix,
+} from './types';
+import { readEntity } from '../io/entity-files';
+
+// --- Theme Cluster Definitions ---
+
+const DEFAULT_THEME_CLUSTERS: ThemeCluster[] = [
+  {
+    name: 'Innovation & Technologie',
+    weight: 40,
+    topics: [
+      'KI-Anwendungen in der Praxis',
+      'Digitalisierung im Konzern',
+      'Neue Technologien bewerten',
+      'AI Act & Regulierung',
+      'Use Cases aus Projekten',
+    ],
+  },
+  {
+    name: 'Mensch & Kultur',
+    weight: 35,
+    topics: [
+      'Change Management',
+      'Führung & Shared Leadership',
+      'Angst vor Technologie überwinden',
+      'Team-Entwicklung',
+      'Fehlerkultur & Lernen',
+    ],
+  },
+  {
+    name: 'Verantwortung',
+    weight: 25,
+    topics: [
+      'Ethik in der KI',
+      'Nachhaltigkeit & Digitalisierung',
+      'DSGVO & Datenschutz',
+      'Gesellschaftliche Auswirkungen von KI',
+      'Verantwortungsvolle Innovation',
+    ],
+  },
+];
+
+// --- Weekly Plan Defaults ---
+
+const DEFAULT_WEEKLY_PLAN: WeeklySlot[] = [
+  {
+    day: 'Dienstag',
+    time: '08:00',
+    format: 'Text',
+    themeCluster: 'Innovation & Technologie',
+  },
+  {
+    day: 'Donnerstag',
+    time: '08:00',
+    format: 'Carousel',
+    themeCluster: 'Mensch & Kultur',
+  },
+];
+
+// --- Format Mix Defaults ---
+
+const DEFAULT_FORMAT_MIX: FormatMix = {
+  text: 40,
+  carousel: 30,
+  video: 15,
+  newsletter: 15,
+};
+
+// --- Engagement Routine Defaults ---
+
+const DEFAULT_ENGAGEMENT_ROUTINE: EngagementRoutine = {
+  commentsPerWeek: 5,
+  targetAccounts: [
+    'KI-Thought-Leader DACH',
+    'Digitalisierungs-Entscheider',
+    'Startup-Gründer Nordhessen',
+    'Bahn-Branche Innovatoren',
+    'Change-Management-Experten',
+  ],
+  dailyTimeMinutes: 15,
+};
+
+// --- Public API ---
+
+/**
+ * Generates a LinkedIn content strategy from KB data.
+ *
+ * Reads the person's profile to understand themes and existing formats,
+ * and produces a quarterly content plan with concrete posting slots,
+ * theme clusters, engagement routine, and format mix.
+ */
+export async function generateContentStrategy(
+  options: ContentStrategyOptions
+): Promise<ContentStrategy> {
+  const { personId, existingFormats = [] } = options;
+
+  const person = (await readEntity('person', personId)) as Person;
+
+  const themeCluster = buildThemeClusters(person);
+  const weeklyPlan = buildWeeklyPlan(themeCluster, existingFormats);
+  const engagementRoutine = buildEngagementRoutine();
+  const formatMix = buildFormatMix(existingFormats);
+
+  return {
+    postingFrequency: '2 Beiträge pro Woche',
+    themeCluster,
+    weeklyPlan,
+    engagementRoutine,
+    formatMix,
+  };
+}
+
+// --- Theme Cluster Building ---
+
+function buildThemeClusters(person: Person): ThemeCluster[] {
+  const clusters = DEFAULT_THEME_CLUSTERS.map((cluster) => ({ ...cluster, topics: [...cluster.topics] }));
+
+  // Enrich topics from person's summary keywords
+  if (person.summary) {
+    if (person.summary.includes('Physik') || person.summary.includes('wissenschaftlich')) {
+      clusters[0].topics.push('Wissenschaft trifft Wirtschaft');
+    }
+    if (person.summary.includes('Angst') || person.summary.includes('Begeisterung')) {
+      clusters[1].topics.push('Von der Angst zur Begeisterung');
+    }
+  }
+
+  return clusters;
+}
+
+// --- Weekly Plan Building ---
+
+function buildWeeklyPlan(clusters: ThemeCluster[], existingFormats: string[]): WeeklySlot[] {
+  const plan: WeeklySlot[] = [...DEFAULT_WEEKLY_PLAN];
+
+  // Integrate existing formats into the weekly plan
+  if (existingFormats.includes('podcast')) {
+    plan.push({
+      day: 'Montag',
+      time: '12:00',
+      format: 'Text',
+      themeCluster: 'Innovation & Technologie',
+    });
+  }
+
+  if (existingFormats.includes('column')) {
+    plan.push({
+      day: 'Sonntag',
+      time: '10:00',
+      format: 'Newsletter',
+      themeCluster: 'Verantwortung',
+    });
+  }
+
+  return plan;
+}
+
+// --- Engagement Routine Building ---
+
+function buildEngagementRoutine(): EngagementRoutine {
+  return { ...DEFAULT_ENGAGEMENT_ROUTINE, targetAccounts: [...DEFAULT_ENGAGEMENT_ROUTINE.targetAccounts] };
+}
+
+// --- Format Mix Building ---
+
+function buildFormatMix(existingFormats: string[]): FormatMix {
+  const mix = { ...DEFAULT_FORMAT_MIX };
+
+  // Adjust mix when existing formats provide additional content sources
+  if (existingFormats.includes('podcast')) {
+    // Podcast episodes can be repurposed as video/carousel content
+    mix.video += 5;
+    mix.text -= 5;
+  }
+
+  if (existingFormats.includes('column')) {
+    // Column content feeds newsletter and text posts
+    mix.newsletter += 5;
+    mix.carousel -= 5;
+  }
+
+  return mix;
+}

privat/CV/src/linkedin/experience-generator.test.ts

@@ -0,0 +1,418 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { generateExperiences } from './experience-generator';
+import { EXPERIENCE_CHAR_LIMIT } from './constraints';
+
+// Mock the entity-files module
+vi.mock('../io/entity-files', () => ({
+  readEntity: vi.fn(),
+  listEntities: vi.fn(),
+}));
+
+import { readEntity } from '../io/entity-files';
+
+const mockReadEntity = vi.mocked(readEntity);
+
+// --- Test Data ---
+
+const mockPerson = {
+  id: 'andre-knie',
+  type: 'person' as const,
+  created: '2024-01-01',
+  modified: '2024-06-01',
+  name: { first: 'Andre', last: 'Knie', display: 'Dr. Andre Knie' },
+  summary: 'Experte für KI, Digitalisierung und Change Management',
+  experiences: [
+    'db-infrago-digitalisierung',
+    'data-hive-cassel-gruender',
+    'db-netz-einfachbahn-jobsharing',
+  ],
+  skills: ['kuenstliche-intelligenz', 'change-management'],
+};
+
+const mockExperienceInfraGO = {
+  id: 'db-infrago-digitalisierung',
+  type: 'experience' as const,
+  created: '2024-01-01',
+  modified: '2024-06-01',
+  title: 'Experte für Digitalisierung',
+  organization: 'db-infrago',
+  start: '2023-01',
+  end: null,
+  description: 'Digitale Transformation der Schieneninfrastruktur',
+  achievements: ['Digitale Transformation vorangetrieben'],
+  skillsUsed: ['kuenstliche-intelligenz', 'change-management', 'digitale-transformation'],
+  projects: [],
+};
+
+const mockExperienceDataHive = {
+  id: 'data-hive-cassel-gruender',
+  type: 'experience' as const,
+  created: '2024-01-01',
+  modified: '2024-06-01',
+  title: 'Gründer & Geschäftsführer',
+  organization: 'data-hive-cassel',
+  start: '2021-01',
+  end: null,
+  description: 'KI-Beratung und Prozessautomatisierung',
+  achievements: ['50+ Projekte umgesetzt', '15+ Kunden betreut'],
+  skillsUsed: ['kuenstliche-intelligenz', 'agilitaet', 'coaching'],
+  projects: [],
+};
+
+const mockExperienceJobSharing = {
+  id: 'db-netz-einfachbahn-jobsharing',
+  type: 'experience' as const,
+  created: '2024-01-01',
+  modified: '2024-06-01',
+  title: 'Leiter #Einfachbahn (JobSharing-Tandem)',
+  organization: 'db-netz',
+  start: '2020-01',
+  end: '2022-12',
+  description: 'Shared Leadership im Konzernumfeld',
+  achievements: ['Shared Leadership etabliert'],
+  skillsUsed: ['shared-leadership', 'agilitaet'],
+  projects: [],
+};
+
+const mockOrgInfraGO = {
+  id: 'db-infrago',
+  type: 'organization' as const,
+  created: '2024-01-01',
+  modified: '2024-06-01',
+  name: 'DB InfraGO',
+  industry: 'Transport & Infrastruktur',
+};
+
+const mockOrgDataHive = {
+  id: 'data-hive-cassel',
+  type: 'organization' as const,
+  created: '2024-01-01',
+  modified: '2024-06-01',
+  name: 'Data Hive Cassel',
+  industry: 'KI-Beratung',
+};
+
+const mockOrgDbNetz = {
+  id: 'db-netz',
+  type: 'organization' as const,
+  created: '2024-01-01',
+  modified: '2024-06-01',
+  name: 'DB Netz AG',
+  industry: 'Transport & Infrastruktur',
+};
+
+// --- Setup ---
+
+function setupMocks() {
+  mockReadEntity.mockImplementation(async (type, id) => {
+    if (type === 'person' && id === 'andre-knie') return mockPerson as any;
+    if (type === 'experience' && id === 'db-infrago-digitalisierung') return mockExperienceInfraGO as any;
+    if (type === 'experience' && id === 'data-hive-cassel-gruender') return mockExperienceDataHive as any;
+    if (type === 'experience' && id === 'db-netz-einfachbahn-jobsharing') return mockExperienceJobSharing as any;
+    if (type === 'organization' && id === 'db-infrago') return mockOrgInfraGO as any;
+    if (type === 'organization' && id === 'data-hive-cassel') return mockOrgDataHive as any;
+    if (type === 'organization' && id === 'db-netz') return mockOrgDbNetz as any;
+    throw new Error(`Entity not found: ${type} "${id}"`);
+  });
+}
+
+// --- Tests ---
+
+describe('generateExperiences', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    setupMocks();
+  });
+
+  describe('Korrekte Zuordnung von Experiences aus KB', () => {
+    it('liest Person-Entity und zugehörige Experiences aus KB', async () => {
+      const results = await generateExperiences({ personId: 'andre-knie' });
+
+      expect(mockReadEntity).toHaveBeenCalledWith('person', 'andre-knie');
+      expect(mockReadEntity).toHaveBeenCalledWith('experience', 'db-infrago-digitalisierung');
+      expect(mockReadEntity).toHaveBeenCalledWith('experience', 'data-hive-cassel-gruender');
+      expect(mockReadEntity).toHaveBeenCalledWith('experience', 'db-netz-einfachbahn-jobsharing');
+    });
+
+    it('generiert Ergebnisse für alle Experiences der Person', async () => {
+      const results = await generateExperiences({ personId: 'andre-knie' });
+
+      expect(results).toHaveLength(3);
+      const ids = results.map((r) => r.experienceId);
+      expect(ids).toContain('db-infrago-digitalisierung');
+      expect(ids).toContain('data-hive-cassel-gruender');
+      expect(ids).toContain('db-netz-einfachbahn-jobsharing');
+    });
+
+    it('generiert nur angeforderte Experiences wenn experienceIds angegeben', async () => {
+      const results = await generateExperiences({
+        personId: 'andre-knie',
+        experienceIds: ['db-infrago-digitalisierung'],
+      });
+
+      expect(results).toHaveLength(1);
+      expect(results[0].experienceId).toBe('db-infrago-digitalisierung');
+    });
+
+    it('löst Organisationsnamen korrekt auf', async () => {
+      const results = await generateExperiences({ personId: 'andre-knie' });
+
+      const infrago = results.find((r) => r.experienceId === 'db-infrago-digitalisierung');
+      expect(infrago?.organization).toBe('DB InfraGO');
+
+      const dataHive = results.find((r) => r.experienceId === 'data-hive-cassel-gruender');
+      expect(dataHive?.organization).toBe('Data Hive Cassel');
+    });
+
+    it('überspringt Experiences die nicht geladen werden können', async () => {
+      mockReadEntity.mockImplementation(async (type, id) => {
+        if (type === 'person' && id === 'andre-knie') return mockPerson as any;
+        if (type === 'experience' && id === 'db-infrago-digitalisierung') return mockExperienceInfraGO as any;
+        if (type === 'experience' && id === 'data-hive-cassel-gruender') throw new Error('Not found');
+        if (type === 'experience' && id === 'db-netz-einfachbahn-jobsharing') return mockExperienceJobSharing as any;
+        if (type === 'organization' && id === 'db-infrago') return mockOrgInfraGO as any;
+        if (type === 'organization' && id === 'db-netz') return mockOrgDbNetz as any;
+        throw new Error(`Entity not found: ${type} "${id}"`);
+      });
+
+      const results = await generateExperiences({ personId: 'andre-knie' });
+
+      expect(results).toHaveLength(2);
+      expect(results.map((r) => r.experienceId)).not.toContain('data-hive-cassel-gruender');
+    });
+  });
+
+  describe('Keyword-Einbindung', () => {
+    it('enthält relevante Keywords in jedem Ergebnis', async () => {
+      const results = await generateExperiences({ personId: 'andre-knie' });
+
+      for (const result of results) {
+        expect(result.keywords).toBeDefined();
+        expect(Array.isArray(result.keywords)).toBe(true);
+        expect(result.keywords.length).toBeGreaterThan(0);
+      }
+    });
+
+    it('integriert angeforderte Keywords in die Ergebnisse', async () => {
+      const requestedKeywords = ['Digitalisierung', 'Innovation'];
+      const results = await generateExperiences({
+        personId: 'andre-knie',
+        keywords: requestedKeywords,
+      });
+
+      for (const result of results) {
+        for (const kw of requestedKeywords) {
+          expect(result.keywords).toContain(kw);
+        }
+      }
+    });
+
+    it('DB InfraGO Experience enthält Digitalisierungs-Keywords', async () => {
+      const results = await generateExperiences({
+        personId: 'andre-knie',
+        experienceIds: ['db-infrago-digitalisierung'],
+      });
+
+      const infrago = results[0];
+      const hasDigitalKeyword = infrago.keywords.some(
+        (kw) => kw.includes('Digital') || kw.includes('Transformation'),
+      );
+      expect(hasDigitalKeyword).toBe(true);
+    });
+
+    it('Data Hive Experience enthält KI-Keywords', async () => {
+      const results = await generateExperiences({
+        personId: 'andre-knie',
+        experienceIds: ['data-hive-cassel-gruender'],
+      });
+
+      const dataHive = results[0];
+      const hasKIKeyword = dataHive.keywords.some(
+        (kw) => kw.includes('KI') || kw.includes('Künstliche Intelligenz'),
+      );
+      expect(hasKIKeyword).toBe(true);
+    });
+  });
+
+  describe('Ergebnis-Struktur', () => {
+    it('jedes Ergebnis hat experienceId, title, organization, description, achievements, keywords, validation', async () => {
+      const results = await generateExperiences({ personId: 'andre-knie' });
+
+      for (const result of results) {
+        expect(result).toHaveProperty('experienceId');
+        expect(result).toHaveProperty('title');
+        expect(result).toHaveProperty('organization');
+        expect(result).toHaveProperty('description');
+        expect(result).toHaveProperty('achievements');
+        expect(result).toHaveProperty('keywords');
+        expect(result).toHaveProperty('validation');
+      }
+    });
+
+    it('experienceId ist ein nicht-leerer String', async () => {
+      const results = await generateExperiences({ personId: 'andre-knie' });
+
+      for (const result of results) {
+        expect(typeof result.experienceId).toBe('string');
+        expect(result.experienceId.length).toBeGreaterThan(0);
+      }
+    });
+
+    it('title ist ein nicht-leerer String', async () => {
+      const results = await generateExperiences({ personId: 'andre-knie' });
+
+      for (const result of results) {
+        expect(typeof result.title).toBe('string');
+        expect(result.title.length).toBeGreaterThan(0);
+      }
+    });
+
+    it('description ist ein nicht-leerer String', async () => {
+      const results = await generateExperiences({ personId: 'andre-knie' });
+
+      for (const result of results) {
+        expect(typeof result.description).toBe('string');
+        expect(result.description.length).toBeGreaterThan(0);
+      }
+    });
+
+    it('achievements ist ein Array von Strings', async () => {
+      const results = await generateExperiences({ personId: 'andre-knie' });
+
+      for (const result of results) {
+        expect(Array.isArray(result.achievements)).toBe(true);
+        for (const achievement of result.achievements) {
+          expect(typeof achievement).toBe('string');
+        }
+      }
+    });
+
+    it('validation enthält valid, errors und warnings', async () => {
+      const results = await generateExperiences({ personId: 'andre-knie' });
+
+      for (const result of results) {
+        expect(result.validation).toHaveProperty('valid');
+        expect(result.validation).toHaveProperty('errors');
+        expect(result.validation).toHaveProperty('warnings');
+        expect(typeof result.validation.valid).toBe('boolean');
+        expect(Array.isArray(result.validation.errors)).toBe(true);
+        expect(Array.isArray(result.validation.warnings)).toBe(true);
+      }
+    });
+  });
+
+  describe('DB InfraGO — ergebnisorientierte Beschreibung', () => {
+    it('enthält ergebnisorientierte Formulierungen statt Aufgabenbeschreibungen', async () => {
+      const results = await generateExperiences({
+        personId: 'andre-knie',
+        experienceIds: ['db-infrago-digitalisierung'],
+      });
+
+      const infrago = results[0];
+      // Should contain result-oriented language
+      const hasResultOrientation =
+        infrago.description.includes('Transformation') ||
+        infrago.description.includes('Ergebnis') ||
+        infrago.description.includes('vorantreib') ||
+        infrago.description.includes('Wirkung') ||
+        infrago.description.includes('Kundennutzen');
+      expect(hasResultOrientation).toBe(true);
+    });
+
+    it('positioniert DB InfraGO als primäre Rolle', async () => {
+      const results = await generateExperiences({
+        personId: 'andre-knie',
+        experienceIds: ['db-infrago-digitalisierung'],
+      });
+
+      const infrago = results[0];
+      expect(infrago.title).toBe('Experte für Digitalisierung');
+      expect(infrago.organization).toBe('DB InfraGO');
+    });
+  });
+
+  describe('Data Hive — messbare Achievements', () => {
+    it('enthält messbare Erfolge (50+ Projekte)', async () => {
+      const results = await generateExperiences({
+        personId: 'andre-knie',
+        experienceIds: ['data-hive-cassel-gruender'],
+      });
+
+      const dataHive = results[0];
+      const allText = dataHive.description + ' ' + dataHive.achievements.join(' ');
+      expect(allText).toContain('50+');
+    });
+
+    it('enthält messbare Erfolge (15+ Kunden)', async () => {
+      const results = await generateExperiences({
+        personId: 'andre-knie',
+        experienceIds: ['data-hive-cassel-gruender'],
+      });
+
+      const dataHive = results[0];
+      const allText = dataHive.description + ' ' + dataHive.achievements.join(' ');
+      expect(allText).toContain('15+');
+    });
+
+    it('enthält messbare Erfolge (ROI > 2)', async () => {
+      const results = await generateExperiences({
+        personId: 'andre-knie',
+        experienceIds: ['data-hive-cassel-gruender'],
+      });
+
+      const dataHive = results[0];
+      const allText = dataHive.description + ' ' + dataHive.achievements.join(' ');
+      expect(allText).toContain('ROI');
+    });
+  });
+
+  describe('JobSharing — Führungsinnovation', () => {
+    it('positioniert JobSharing als Führungsinnovation', async () => {
+      const results = await generateExperiences({
+        personId: 'andre-knie',
+        experienceIds: ['db-netz-einfachbahn-jobsharing'],
+      });
+
+      const jobSharing = results[0];
+      const allText = jobSharing.description + ' ' + jobSharing.achievements.join(' ');
+      const hasLeadershipInnovation =
+        allText.includes('Führungsinnovation') ||
+        allText.includes('Shared Leadership') ||
+        allText.includes('JobSharing') ||
+        allText.includes('geteilte Führung');
+      expect(hasLeadershipInnovation).toBe(true);
+    });
+
+    it('enthält Achievements zum Thema Shared Leadership', async () => {
+      const results = await generateExperiences({
+        personId: 'andre-knie',
+        experienceIds: ['db-netz-einfachbahn-jobsharing'],
+      });
+
+      const jobSharing = results[0];
+      const hasSharedLeadership = jobSharing.achievements.some(
+        (a) => a.includes('Shared Leadership') || a.includes('Führung') || a.includes('Tandem'),
+      );
+      expect(hasSharedLeadership).toBe(true);
+    });
+  });
+
+  describe('Zeichenlimit-Einhaltung', () => {
+    it('alle Beschreibungen bleiben unter 2.000 Zeichen', async () => {
+      const results = await generateExperiences({ personId: 'andre-knie' });
+
+      for (const result of results) {
+        expect(result.description.length).toBeLessThanOrEqual(EXPERIENCE_CHAR_LIMIT);
+      }
+    });
+
+    it('Validierung ist valid für alle generierten Beschreibungen', async () => {
+      const results = await generateExperiences({ personId: 'andre-knie' });
+
+      for (const result of results) {
+        expect(result.validation.valid).toBe(true);
+        expect(result.validation.errors).toHaveLength(0);
+      }
+    });
+  });
+});

privat/CV/src/linkedin/experience-generator.ts

@@ -0,0 +1,399 @@
+/**
+ * LinkedIn Experience Generator
+ *
+ * Generates result-oriented LinkedIn experience descriptions from KB data.
+ * Reads person experiences, skills, and projects, then produces optimized
+ * descriptions with measurable achievements and relevant keywords.
+ */
+
+import type { Person, Experience, Organization, Skill, Project } from '../schemas/types';
+import type { ExperienceOptions, ExperienceResult } from './types';
+import { validateExperience, EXPERIENCE_CHAR_LIMIT } from './constraints';
+import { readEntity } from '../io/entity-files';
+
+// --- Internal Types ---
+
+interface ExperienceData {
+  experience: Experience;
+  orgName: string;
+  skills: Skill[];
+  projects: Project[];
+}
+
+// --- Experience Positioning Strategies ---
+
+/**
+ * Maps experience IDs to positioning strategies that generate
+ * result-oriented descriptions instead of task lists.
+ */
+const POSITIONING_STRATEGIES: Record<string, (data: ExperienceData, keywords: string[]) => PositionedContent> = {
+  'db-infrago-digitalisierung': positionDbInfraGo,
+  'data-hive-cassel-gruender': positionDataHive,
+  'db-netz-einfachbahn-jobsharing': positionJobSharing,
+  'db-netz-einfachbahn-leiter': positionEinfachbahnLeiter,
+  'uni-kassel-teilgruppenleiter': positionAcademicLeader,
+  'uni-kassel-doktorand': positionAcademicFoundation,
+  'uni-kassel-dozent-physik': positionAcademicTeaching,
+  'hochschule-fresenius-dozent': positionFreseniusDozent,
+};
+
+interface PositionedContent {
+  description: string;
+  achievements: string[];
+  keywords: string[];
+}
+
+// --- Public API ---
+
+/**
+ * Generates LinkedIn experience descriptions from KB data.
+ *
+ * Reads the person's experiences, enriches them with skills and projects,
+ * and produces result-oriented descriptions validated against LinkedIn constraints.
+ */
+export async function generateExperiences(options: ExperienceOptions): Promise<ExperienceResult[]> {
+  const { personId, experienceIds, keywords = [] } = options;
+
+  const person = (await readEntity('person', personId)) as Person;
+  const targetIds = experienceIds ?? person.experiences ?? [];
+
+  const results: ExperienceResult[] = [];
+
+  for (const expId of targetIds) {
+    try {
+      const data = await loadExperienceData(expId);
+      const positioned = generatePositionedContent(data, keywords);
+      const description = truncateToLimit(positioned.description);
+      const validation = validateExperience(description);
+
+      results.push({
+        experienceId: expId,
+        title: data.experience.title,
+        organization: data.orgName,
+        description,
+        keywords: positioned.keywords,
+        achievements: positioned.achievements,
+        validation,
+      });
+    } catch {
+      // Skip experiences that cannot be loaded
+    }
+  }
+
+  return results;
+}
+
+// --- Data Loading ---
+
+async function loadExperienceData(expId: string): Promise<ExperienceData> {
+  const experience = (await readEntity('experience', expId)) as Experience;
+
+  let orgName = experience.organization;
+  try {
+    const org = (await readEntity('organization', experience.organization)) as Organization;
+    orgName = org.name;
+  } catch {
+    // Use raw org ID as fallback
+  }
+
+  const skills: Skill[] = [];
+  for (const skillId of experience.skillsUsed ?? []) {
+    try {
+      const skill = (await readEntity('skill', skillId)) as Skill;
+      skills.push(skill);
+    } catch {
+      // Skip missing skills
+    }
+  }
+
+  const projects: Project[] = [];
+  for (const projId of experience.projects ?? []) {
+    try {
+      const project = (await readEntity('project', projId)) as Project;
+      projects.push(project);
+    } catch {
+      // Skip missing projects
+    }
+  }
+
+  return { experience, orgName, skills, projects };
+}
+
+// --- Content Generation ---
+
+function generatePositionedContent(data: ExperienceData, requestedKeywords: string[]): PositionedContent {
+  const strategy = POSITIONING_STRATEGIES[data.experience.id];
+
+  if (strategy) {
+    return strategy(data, requestedKeywords);
+  }
+
+  return generateDefaultContent(data, requestedKeywords);
+}
+
+// --- Positioning Strategies ---
+
+function positionDbInfraGo(data: ExperienceData, requestedKeywords: string[]): PositionedContent {
+  const description = [
+    'Digitalen Kundennutzen schaffen — mit einem Blick für Technologie und Menschen.',
+    '',
+    'Als Experte für Digitalisierung bei DB InfraGO treibe ich die digitale Transformation der Schieneninfrastruktur voran. Mein Fokus: Projekte effizient zum Abschluss bringen und das System Schiene zukunftsfähig machen.',
+    '',
+    'Schwerpunkte:',
+    '→ Digitale Transformation großer Infrastrukturprojekte',
+    '→ Change Management an der Schnittstelle von IT und Fachbereichen',
+    '→ Teamführung mit Fokus auf Ergebnisse und Wirkung',
+  ].join('\n');
+
+  const achievements = [
+    'Digitale Transformation der Schieneninfrastruktur vorangetrieben',
+    'Effiziente Projektsteuerung in komplexem Konzernumfeld',
+  ];
+
+  const keywords = mergeKeywords(
+    ['Digitalisierung', 'Digitale Transformation', 'Change Management', 'Infrastruktur', 'DB', 'Schienenverkehr'],
+    requestedKeywords,
+  );
+
+  return { description, achievements, keywords };
+}
+
+function positionDataHive(data: ExperienceData, requestedKeywords: string[]): PositionedContent {
+  const description = [
+    'Wir hassen Verschwendung und lieben Wandel.',
+    '',
+    'Als Gründer von Data Hive Cassel verbinde ich KI-Expertise mit echtem Veränderungswillen. Mein Anspruch: nicht nur technische Lösungen liefern, sondern nachhaltigen Wandel ermöglichen.',
+    '',
+    'Ergebnisse:',
+    '→ 50+ Projekte erfolgreich umgesetzt',
+    '→ 15+ Kunden aus Mittelstand und öffentlichem Sektor',
+    '→ ROI > 2 für Kunden durch datengetriebene Optimierung',
+    '→ KI praxistauglich gemacht — von der Strategie bis zur Implementierung',
+    '',
+    'Schwerpunkte: KI-Beratung, Prozessautomatisierung, Energieeffizienz, Change Management',
+  ].join('\n');
+
+  const achievements = [
+    '50+ Projekte erfolgreich umgesetzt',
+    '15+ Kunden aus Mittelstand und öffentlichem Sektor',
+    'ROI > 2 für Kunden durch datengetriebene Optimierung',
+    'KI praxistauglich gemacht — von der Strategie bis zur Implementierung',
+  ];
+
+  const keywords = mergeKeywords(
+    ['Künstliche Intelligenz', 'KI-Beratung', 'Startup', 'Gründer', 'Prozessautomatisierung', 'Change Management', 'Energieeffizienz', 'ROI'],
+    requestedKeywords,
+  );
+
+  return { description, achievements, keywords };
+}
+
+function positionJobSharing(data: ExperienceData, requestedKeywords: string[]): PositionedContent {
+  const description = [
+    'Führung ist keine One-Man-Show — und das haben wir bewiesen.',
+    '',
+    'Im JobSharing-Tandem mit Claudia Froldi haben wir geteilte Führung auf Augenhöhe im Konzernumfeld etabliert. Ein bewusstes Experiment: Gehaltsverzicht für ein innovatives Führungsmodell.',
+    '',
+    'Ergebnisse:',
+    '→ Shared Leadership als Führungsinnovation im DB-Konzern etabliert',
+    '→ Komplementäre Stärken: Fachliche Führung + disziplinarische Führung',
+    '→ Team #Einfachbahn erfolgreich durch Transformation begleitet',
+    '→ Vorbild für neue Arbeitsmodelle in der Bahnbranche',
+  ].join('\n');
+
+  const achievements = [
+    'Shared Leadership als Führungsinnovation im DB-Konzern etabliert',
+    'Bewusster Gehaltsverzicht für geteilte Führung auf Augenhöhe',
+    'Team erfolgreich durch Transformation begleitet',
+  ];
+
+  const keywords = mergeKeywords(
+    ['Shared Leadership', 'JobSharing', 'Führungsinnovation', 'New Work', 'Tandem-Führung', 'Transformation'],
+    requestedKeywords,
+  );
+
+  return { description, achievements, keywords };
+}
+
+function positionEinfachbahnLeiter(data: ExperienceData, requestedKeywords: string[]): PositionedContent {
+  const description = [
+    'Die Digitalisierung auf die Schiene bringen — eines der ambitioniertesten Vorhaben im Konzernumfeld.',
+    '',
+    'Als Leiter #Einfachbahn habe ich ein interdisziplinäres Team aufgebaut und zu Höchstleistungen geführt. Agile Methoden und innovative Arbeitsformen etabliert, Silos aufgebrochen.',
+    '',
+    'Ergebnisse:',
+    '→ Interdisziplinäres Team aufgebaut und agile Methoden etabliert',
+    '→ Kultur des offenen Lernens geschaffen',
+    '→ Technische und kulturelle Transformation nachhaltig vorangetrieben',
+  ].join('\n');
+
+  const achievements = data.experience.achievements ?? [
+    'Interdisziplinäres Team aufgebaut und agile Methoden etabliert',
+    'Silos aufgebrochen und Kultur des offenen Lernens geschaffen',
+  ];
+
+  const keywords = mergeKeywords(
+    ['Digitalisierung', 'Agile Führung', 'Transformation', 'Teamaufbau', 'Change Management'],
+    requestedKeywords,
+  );
+
+  return { description, achievements, keywords };
+}
+
+function positionAcademicLeader(data: ExperienceData, requestedKeywords: string[]): PositionedContent {
+  const description = [
+    'Vom Labor in die Praxis — hier wurde das Fundament für meine KI-Expertise gelegt.',
+    '',
+    'Als Teilgruppenleiter Spektroskopie habe ich Forschung, Teamführung und Technologieentwicklung vereint. Machine Learning seit 2012 in der Praxis angewandt — lange bevor es Mainstream wurde.',
+    '',
+    'Ergebnisse:',
+    '→ 50+ wissenschaftliche Veröffentlichungen, 2.000+ Zitationen',
+    '→ 12 Mio. € Drittmittel eingeworben (DFG, BMBF, EU)',
+    '→ Internationale Forschungsteams aufgebaut und geführt',
+    '→ ML/PyTorch seit 2012 für Datenanalyse eingesetzt',
+  ].join('\n');
+
+  const achievements = [
+    '50+ wissenschaftliche Veröffentlichungen, 2.000+ Zitationen',
+    '12 Mio. € Drittmittel eingeworben (DFG, BMBF, EU)',
+    'Internationale Forschungsteams aufgebaut und geführt',
+    'ML/PyTorch seit 2012 für Datenanalyse eingesetzt',
+  ];
+
+  const keywords = mergeKeywords(
+    ['Machine Learning', 'Forschung', 'Künstliche Intelligenz', 'Teamführung', 'Drittmittel', 'Publikationen'],
+    requestedKeywords,
+  );
+
+  return { description, achievements, keywords };
+}
+
+function positionAcademicFoundation(data: ExperienceData, requestedKeywords: string[]): PositionedContent {
+  const description = [
+    'Wissenschaftliche Exzellenz als Grundlage für praxisnahe KI-Anwendungen.',
+    '',
+    'Promotion in Atom- und Molekülphysik mit Fokus auf experimentelle Methoden und Datenanalyse. Die analytische Denkweise und der systematische Ansatz prägen bis heute meine Arbeit mit KI und Digitalisierung.',
+    '',
+    'Ergebnisse:',
+    '→ 10 wissenschaftliche Paper und 10 internationale Konferenzbeiträge',
+    '→ Elektronenstrahlquelle von Simulation bis Konstruktion aufgebaut',
+    '→ Grundstein für 13+ Jahre KI-Erfahrung gelegt',
+  ].join('\n');
+
+  const achievements = [
+    '10 wissenschaftliche Paper und 10 internationale Konferenzbeiträge',
+    'Elektronenstrahlquelle von Simulation bis Konstruktion aufgebaut',
+    'Grundstein für 13+ Jahre KI-Erfahrung gelegt',
+  ];
+
+  const keywords = mergeKeywords(
+    ['Promotion', 'Physik', 'Forschung', 'Datenanalyse', 'Wissenschaft'],
+    requestedKeywords,
+  );
+
+  return { description, achievements, keywords };
+}
+
+function positionAcademicTeaching(data: ExperienceData, requestedKeywords: string[]): PositionedContent {
+  const description = [
+    'Komplexe Themen verständlich machen — eine Kompetenz, die von der Physik bis zur KI-Beratung trägt.',
+    '',
+    'Als Dozent für experimentelle Atom- und Molekülphysik habe ich gelernt, anspruchsvolle Inhalte so aufzubereiten, dass sie begeistern und verstanden werden.',
+  ].join('\n');
+
+  const achievements = [
+    'Komplexe wissenschaftliche Inhalte verständlich vermittelt',
+  ];
+
+  const keywords = mergeKeywords(
+    ['Lehre', 'Wissensvermittlung', 'Physik', 'Universität'],
+    requestedKeywords,
+  );
+
+  return { description, achievements, keywords };
+}
+
+function positionFreseniusDozent(data: ExperienceData, requestedKeywords: string[]): PositionedContent {
+  const description = [
+    'Agilität, Change und Innovation erlebbar machen — nicht nur theoretisch, sondern am eigenen Leib.',
+    '',
+    'Als Dozent an der Hochschule Fresenius habe ich MBA-Studierenden gezeigt, warum Agilität, Change, Innovation und Führung zusammengehören. Praxisnah, interaktiv und mit echten Erfahrungen aus Konzern und Startup.',
+  ].join('\n');
+
+  const achievements = [
+    'MBA-Studierende für Agilität und Innovation begeistert',
+    'Praxiswissen aus Konzern und Startup in die Lehre eingebracht',
+  ];
+
+  const keywords = mergeKeywords(
+    ['Agilität', 'Change Management', 'Innovation', 'Führung', 'Lehre', 'MBA'],
+    requestedKeywords,
+  );
+
+  return { description, achievements, keywords };
+}
+
+// --- Default Content Generation ---
+
+function generateDefaultContent(data: ExperienceData, requestedKeywords: string[]): PositionedContent {
+  const description = data.experience.description?.trim() ?? data.experience.title;
+  const achievements = data.experience.achievements ?? [];
+  const keywords = mergeKeywords(
+    extractSkillKeywords(data.skills),
+    requestedKeywords,
+  );
+
+  return { description, achievements, keywords };
+}
+
+// --- Keyword Helpers ---
+
+const SKILL_KEYWORD_MAP: Record<string, string> = {
+  'kuenstliche-intelligenz': 'Künstliche Intelligenz',
+  'change-management': 'Change Management',
+  'digitale-transformation': 'Digitale Transformation',
+  'shared-leadership': 'Shared Leadership',
+  'agilitaet': 'Agilität',
+  'coaching': 'Coaching',
+  'team-management': 'Teamführung',
+  'it-strategie': 'IT-Strategie',
+};
+
+function extractSkillKeywords(skills: Skill[]): string[] {
+  const keywords: string[] = [];
+  for (const skill of skills) {
+    const mapped = SKILL_KEYWORD_MAP[skill.id];
+    if (mapped) {
+      keywords.push(mapped);
+    } else {
+      keywords.push(skill.name);
+    }
+  }
+  return keywords;
+}
+
+function mergeKeywords(base: string[], requested: string[]): string[] {
+  const merged = new Set<string>(base);
+  for (const kw of requested) {
+    merged.add(kw);
+  }
+  return Array.from(merged);
+}
+
+// --- Constraint Helpers ---
+
+function truncateToLimit(text: string): string {
+  if (text.length <= EXPERIENCE_CHAR_LIMIT) {
+    return text;
+  }
+  const truncated = text.slice(0, EXPERIENCE_CHAR_LIMIT - 1);
+  const lastNewline = truncated.lastIndexOf('\n');
+  if (lastNewline > EXPERIENCE_CHAR_LIMIT * 0.7) {
+    return truncated.slice(0, lastNewline);
+  }
+  const lastSpace = truncated.lastIndexOf(' ');
+  if (lastSpace > EXPERIENCE_CHAR_LIMIT * 0.7) {
+    return truncated.slice(0, lastSpace) + '…';
+  }
+  return truncated + '…';
+}

privat/CV/src/linkedin/headline-generator.test.ts

@@ -0,0 +1,235 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { generateHeadlines } from './headline-generator';
+import { HEADLINE_CHAR_LIMIT } from './constraints';
+
+// Mock the entity-files module
+vi.mock('../io/entity-files', () => ({
+  readEntity: vi.fn(),
+  listEntities: vi.fn(),
+}));
+
+import { readEntity } from '../io/entity-files';
+
+const mockReadEntity = vi.mocked(readEntity);
+
+// --- Test Data ---
+
+const mockPerson = {
+  id: 'andre-knie',
+  type: 'person' as const,
+  created: '2024-01-01',
+  modified: '2024-06-01',
+  name: { first: 'Andre', last: 'Knie', display: 'Dr. Andre Knie' },
+  summary: 'Experte für KI, Digitalisierung und Change Management',
+  education: [
+    { institution: 'Universität Kassel', degree: 'Dr. rer. nat.', field: 'Physik', start: '2010', end: '2014' },
+  ],
+  experiences: ['db-infrago-digitalisierung', 'data-hive-cassel-gruender'],
+  skills: ['kuenstliche-intelligenz', 'change-management'],
+};
+
+const mockExperienceInfraGO = {
+  id: 'db-infrago-digitalisierung',
+  type: 'experience' as const,
+  created: '2024-01-01',
+  modified: '2024-06-01',
+  title: 'Experte für Digitalisierung',
+  organization: 'db-infrago',
+  start: '2023-01',
+  end: null,
+  skillsUsed: ['kuenstliche-intelligenz', 'change-management', 'digitale-transformation'],
+};
+
+const mockExperienceDataHive = {
+  id: 'data-hive-cassel-gruender',
+  type: 'experience' as const,
+  created: '2024-01-01',
+  modified: '2024-06-01',
+  title: 'Gründer & Geschäftsführer',
+  organization: 'data-hive-cassel',
+  start: '2021-01',
+  end: null,
+  skillsUsed: ['kuenstliche-intelligenz', 'agilitaet', 'coaching'],
+};
+
+const mockOrgInfraGO = {
+  id: 'db-infrago',
+  type: 'organization' as const,
+  created: '2024-01-01',
+  modified: '2024-06-01',
+  name: 'DB InfraGO',
+  industry: 'Transport & Infrastruktur',
+};
+
+const mockOrgDataHive = {
+  id: 'data-hive-cassel',
+  type: 'organization' as const,
+  created: '2024-01-01',
+  modified: '2024-06-01',
+  name: 'Data Hive Cassel',
+  industry: 'KI-Beratung',
+};
+
+// --- Setup ---
+
+function setupMocks() {
+  mockReadEntity.mockImplementation(async (type, id) => {
+    if (type === 'person' && id === 'andre-knie') return mockPerson as any;
+    if (type === 'experience' && id === 'db-infrago-digitalisierung') return mockExperienceInfraGO as any;
+    if (type === 'experience' && id === 'data-hive-cassel-gruender') return mockExperienceDataHive as any;
+    if (type === 'organization' && id === 'db-infrago') return mockOrgInfraGO as any;
+    if (type === 'organization' && id === 'data-hive-cassel') return mockOrgDataHive as any;
+    throw new Error(`Entity not found: ${type} "${id}"`);
+  });
+}
+
+// --- Tests ---
+
+describe('generateHeadlines', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    setupMocks();
+  });
+
+  describe('Rollenextraktion aus KB', () => {
+    it('enthält beide Rollen (DB InfraGO + Data Hive Cassel) in den Varianten', async () => {
+      const result = await generateHeadlines({ personId: 'andre-knie' });
+
+      // At least one variant should mention DB InfraGO
+      const hasInfraGO = result.variants.some(
+        (v) => v.text.includes('DB InfraGO') || v.roles.some((r) => r.includes('DB InfraGO'))
+      );
+      expect(hasInfraGO).toBe(true);
+
+      // At least one variant should mention Data Hive Cassel
+      const hasDataHive = result.variants.some(
+        (v) => v.text.includes('Data Hive Cassel') || v.roles.some((r) => r.includes('Data Hive Cassel'))
+      );
+      expect(hasDataHive).toBe(true);
+    });
+
+    it('extrahiert Rollen-Metadaten korrekt in HeadlineVariant.roles', async () => {
+      const result = await generateHeadlines({ personId: 'andre-knie' });
+
+      // Each variant that mentions an org should have it in roles
+      for (const variant of result.variants) {
+        if (variant.text.includes('DB InfraGO')) {
+          expect(variant.roles.some((r) => r.includes('DB InfraGO'))).toBe(true);
+        }
+        if (variant.text.includes('Data Hive Cassel')) {
+          expect(variant.roles.some((r) => r.includes('Data Hive Cassel'))).toBe(true);
+        }
+      }
+    });
+
+    it('liest Person-Entity und zugehörige Experiences aus KB', async () => {
+      await generateHeadlines({ personId: 'andre-knie' });
+
+      expect(mockReadEntity).toHaveBeenCalledWith('person', 'andre-knie');
+      expect(mockReadEntity).toHaveBeenCalledWith('experience', 'db-infrago-digitalisierung');
+      expect(mockReadEntity).toHaveBeenCalledWith('experience', 'data-hive-cassel-gruender');
+    });
+  });
+
+  describe('Zeichenlimit-Einhaltung', () => {
+    it('alle Varianten bleiben unter 220 Zeichen', async () => {
+      const result = await generateHeadlines({ personId: 'andre-knie' });
+
+      for (const variant of result.variants) {
+        expect(variant.charCount).toBeLessThanOrEqual(HEADLINE_CHAR_LIMIT);
+        expect(variant.text.length).toBeLessThanOrEqual(HEADLINE_CHAR_LIMIT);
+      }
+    });
+
+    it('charCount stimmt mit tatsächlicher Textlänge überein', async () => {
+      const result = await generateHeadlines({ personId: 'andre-knie' });
+
+      for (const variant of result.variants) {
+        expect(variant.charCount).toBe(variant.text.length);
+      }
+    });
+
+    it('Validierung ist valid wenn alle Varianten unter dem Limit sind', async () => {
+      const result = await generateHeadlines({ personId: 'andre-knie' });
+
+      expect(result.validation.valid).toBe(true);
+      expect(result.validation.errors).toHaveLength(0);
+    });
+  });
+
+  describe('Variantengenerierung', () => {
+    it('generiert standardmäßig 3 Varianten', async () => {
+      const result = await generateHeadlines({ personId: 'andre-knie' });
+
+      expect(result.variants).toHaveLength(3);
+    });
+
+    it('generiert konfigurierbare Anzahl an Varianten', async () => {
+      const result = await generateHeadlines({ personId: 'andre-knie', variants: 5 });
+
+      expect(result.variants).toHaveLength(5);
+    });
+
+    it('generiert 1 Variante wenn variants=1', async () => {
+      const result = await generateHeadlines({ personId: 'andre-knie', variants: 1 });
+
+      expect(result.variants).toHaveLength(1);
+    });
+
+    it('jede Variante hat nicht-leeren Text', async () => {
+      const result = await generateHeadlines({ personId: 'andre-knie' });
+
+      for (const variant of result.variants) {
+        expect(variant.text.length).toBeGreaterThan(0);
+      }
+    });
+
+    it('jede Variante enthält keywords Array', async () => {
+      const result = await generateHeadlines({ personId: 'andre-knie' });
+
+      for (const variant of result.variants) {
+        expect(Array.isArray(variant.keywords)).toBe(true);
+      }
+    });
+  });
+
+  describe('Emphasis-Modi', () => {
+    it('dual-role Modus generiert Headlines mit beiden Organisationen', async () => {
+      const result = await generateHeadlines({ personId: 'andre-knie', emphasis: 'dual-role' });
+
+      const allTexts = result.variants.map((v) => v.text).join(' ');
+      expect(allTexts).toContain('DB InfraGO');
+      expect(allTexts).toContain('Data Hive Cassel');
+    });
+
+    it('ai-expert Modus enthält KI-bezogene Begriffe', async () => {
+      const result = await generateHeadlines({ personId: 'andre-knie', emphasis: 'ai-expert' });
+
+      const allTexts = result.variants.map((v) => v.text).join(' ');
+      const hasKIReference = allTexts.includes('KI') || allTexts.includes('Künstliche Intelligenz');
+      expect(hasKIReference).toBe(true);
+    });
+
+    it('leadership Modus enthält Führungs-bezogene Begriffe', async () => {
+      const result = await generateHeadlines({ personId: 'andre-knie', emphasis: 'leadership' });
+
+      const allTexts = result.variants.map((v) => v.text).join(' ');
+      const hasLeadershipRef =
+        allTexts.includes('Führung') ||
+        allTexts.includes('Konzern') ||
+        allTexts.includes('Startup');
+      expect(hasLeadershipRef).toBe(true);
+    });
+
+    it('alle Emphasis-Modi halten das Zeichenlimit ein', async () => {
+      const modes: Array<'dual-role' | 'ai-expert' | 'leadership'> = ['dual-role', 'ai-expert', 'leadership'];
+
+      for (const emphasis of modes) {
+        const result = await generateHeadlines({ personId: 'andre-knie', emphasis });
+        for (const variant of result.variants) {
+          expect(variant.charCount).toBeLessThanOrEqual(HEADLINE_CHAR_LIMIT);
+        }
+      }
+    });
+  });
+});

privat/CV/src/linkedin/headline-generator.ts

@@ -0,0 +1,236 @@
+/**
+ * LinkedIn Headline Generator
+ *
+ * Generates optimized LinkedIn headline variants from KB data.
+ * Reads person profile and experiences, extracts roles and keywords,
+ * and produces multiple headline variants with constraint validation.
+ */
+
+import type { Person, Experience, Organization } from '../schemas/types';
+import type { HeadlineOptions, HeadlineResult, HeadlineVariant } from './types';
+import { validateHeadline, HEADLINE_CHAR_LIMIT } from './constraints';
+import { readEntity, listEntities } from '../io/entity-files';
+
+// --- Internal Types ---
+
+interface RoleInfo {
+  title: string;
+  organization: string;
+  orgId: string;
+}
+
+interface ProfileData {
+  person: Person;
+  currentRoles: RoleInfo[];
+  keywords: string[];
+}
+
+// --- Headline Templates by Emphasis ---
+
+type EmphasisType = NonNullable<HeadlineOptions['emphasis']>;
+
+interface TemplateFunction {
+  (data: ProfileData): string;
+}
+
+const TEMPLATES: Record<EmphasisType, TemplateFunction[]> = {
+  'dual-role': [
+    (d) => `${d.currentRoles.map((r) => `${r.title} @ ${r.organization}`).join(' | ')} — ${getDifferentiator(d)}`,
+    (d) => `${getDifferentiator(d)} | ${d.currentRoles.map((r) => `${r.title}, ${r.organization}`).join(' & ')}`,
+    (d) => `${d.currentRoles[0]?.title} (${d.currentRoles[0]?.organization}) + ${d.currentRoles[1]?.title} (${d.currentRoles[1]?.organization}) | ${getTopKeywords(d, 2)}`,
+  ],
+  'ai-expert': [
+    (d) => `KI-Experte & ${d.currentRoles[0]?.title} | ${d.currentRoles.map((r) => r.organization).join(' + ')} | ${getDifferentiator(d)}`,
+    (d) => `${getDifferentiator(d)} | KI, Digitalisierung & Führung | ${d.currentRoles.map((r) => r.organization).join(' + ')}`,
+    (d) => `Künstliche Intelligenz × Praxis | ${d.currentRoles.map((r) => `${r.title} @ ${r.organization}`).join(' | ')}`,
+  ],
+  'leadership': [
+    (d) => `Führung an der Schnittstelle von Konzern & Startup | ${d.currentRoles.map((r) => r.organization).join(' + ')} | ${getDifferentiator(d)}`,
+    (d) => `${d.currentRoles[0]?.title} @ ${d.currentRoles[0]?.organization} | ${d.currentRoles[1]?.title} @ ${d.currentRoles[1]?.organization} | ${getDifferentiator(d)}`,
+    (d) => `Konzern trifft Startup: ${d.currentRoles.map((r) => `${r.title}, ${r.organization}`).join(' & ')} | ${getTopKeywords(d, 2)}`,
+  ],
+};
+
+// --- Public API ---
+
+/**
+ * Generates LinkedIn headline variants from KB data.
+ *
+ * Reads the person's profile and current experiences, extracts roles and keywords,
+ * and produces multiple headline variants validated against LinkedIn constraints.
+ */
+export async function generateHeadlines(options: HeadlineOptions): Promise<HeadlineResult> {
+  const { personId, emphasis = 'dual-role', variants = 3 } = options;
+
+  const profileData = await loadProfileData(personId);
+  const rawVariants = buildVariants(profileData, emphasis, variants);
+
+  // Validate all variants — report the worst-case validation
+  const validatedVariants: HeadlineVariant[] = [];
+  let worstValidation = validateHeadline('placeholder');
+  worstValidation = { valid: true, errors: [], warnings: [] };
+
+  for (const text of rawVariants) {
+    const trimmed = truncateToLimit(text);
+    const validation = validateHeadline(trimmed);
+    const variant = buildVariantMetadata(trimmed, profileData);
+    validatedVariants.push(variant);
+
+    if (!validation.valid) {
+      worstValidation = validation;
+    } else if (validation.warnings.length > 0 && worstValidation.valid) {
+      worstValidation = validation;
+    }
+  }
+
+  return {
+    variants: validatedVariants,
+    validation: worstValidation,
+  };
+}
+
+// --- Data Loading ---
+
+async function loadProfileData(personId: string): Promise<ProfileData> {
+  const person = (await readEntity('person', personId)) as Person;
+
+  const experienceIds = person.experiences ?? [];
+  const experiences: Experience[] = [];
+
+  for (const expId of experienceIds) {
+    try {
+      const exp = (await readEntity('experience', expId)) as Experience;
+      experiences.push(exp);
+    } catch {
+      // Skip missing experiences
+    }
+  }
+
+  const currentExperiences = experiences.filter((e) => e.end === null);
+  const currentRoles: RoleInfo[] = [];
+
+  for (const exp of currentExperiences) {
+    let orgName = exp.organization;
+    try {
+      const org = (await readEntity('organization', exp.organization)) as Organization;
+      orgName = org.name;
+    } catch {
+      // Use raw org ID as fallback
+    }
+    currentRoles.push({
+      title: exp.title,
+      organization: orgName,
+      orgId: exp.organization,
+    });
+  }
+
+  const keywords = extractKeywords(person, currentExperiences);
+
+  return { person, currentRoles, keywords };
+}
+
+// --- Variant Building ---
+
+function buildVariants(data: ProfileData, emphasis: EmphasisType, count: number): string[] {
+  const templates = TEMPLATES[emphasis];
+  const results: string[] = [];
+
+  for (let i = 0; i < count; i++) {
+    const templateIndex = i % templates.length;
+    const text = templates[templateIndex](data);
+    results.push(text);
+  }
+
+  return results;
+}
+
+function buildVariantMetadata(text: string, data: ProfileData): HeadlineVariant {
+  const roles = data.currentRoles
+    .filter((r) => text.includes(r.organization) || text.includes(r.title))
+    .map((r) => `${r.title} @ ${r.organization}`);
+
+  const keywords = data.keywords.filter((kw) => text.toLowerCase().includes(kw.toLowerCase()));
+
+  return {
+    text,
+    charCount: text.length,
+    keywords,
+    roles,
+  };
+}
+
+// --- Keyword Extraction ---
+
+function extractKeywords(person: Person, experiences: Experience[]): string[] {
+  const keywords = new Set<string>();
+
+  // From person summary
+  const summaryKeywords = ['KI', 'Digitalisierung', 'Change', 'Innovation', 'Führung', 'Technologie'];
+  for (const kw of summaryKeywords) {
+    if (person.summary?.includes(kw)) {
+      keywords.add(kw);
+    }
+  }
+
+  // From experience skills
+  const skillKeywordMap: Record<string, string> = {
+    'kuenstliche-intelligenz': 'KI',
+    'change-management': 'Change Management',
+    'digitale-transformation': 'Digitalisierung',
+    'shared-leadership': 'Shared Leadership',
+    'agilitaet': 'Agilität',
+    'coaching': 'Coaching',
+    'team-management': 'Teamführung',
+    'it-strategie': 'IT-Strategie',
+  };
+
+  for (const exp of experiences) {
+    for (const skillId of exp.skillsUsed ?? []) {
+      if (skillKeywordMap[skillId]) {
+        keywords.add(skillKeywordMap[skillId]);
+      }
+    }
+  }
+
+  return Array.from(keywords);
+}
+
+// --- Differentiating Elements ---
+
+function getDifferentiator(data: ProfileData): string {
+  const differentiators = [
+    'Physiker macht KI praxistauglich',
+    'Angst vor Technologie überwinden',
+    'Konzern × Startup',
+    'Wissenschaft trifft Wirtschaft',
+    'KI mit Haltung',
+  ];
+
+  // Pick based on emphasis and available data
+  if (data.person.education?.some((e) => e.field?.includes('Physik'))) {
+    return differentiators[0];
+  }
+  if (data.currentRoles.length >= 2) {
+    return differentiators[2];
+  }
+  return differentiators[1];
+}
+
+function getTopKeywords(data: ProfileData, count: number): string {
+  return data.keywords.slice(0, count).join(' | ');
+}
+
+// --- Constraint Helpers ---
+
+function truncateToLimit(text: string): string {
+  if (text.length <= HEADLINE_CHAR_LIMIT) {
+    return text;
+  }
+  // Truncate at last space before limit, add ellipsis
+  const truncated = text.slice(0, HEADLINE_CHAR_LIMIT - 1);
+  const lastSpace = truncated.lastIndexOf(' ');
+  if (lastSpace > HEADLINE_CHAR_LIMIT * 0.7) {
+    return truncated.slice(0, lastSpace) + '…';
+  }
+  return truncated + '…';
+}

privat/CV/src/linkedin/linkedin.integration.test.ts

@@ -0,0 +1,779 @@
+/**
+ * Integration Tests for LinkedIn Module
+ *
+ * Tests the end-to-end flows:
+ * - KB lesen → Profil-Generierung → Output schreiben
+ * - Content-Strategie-Generierung → Output schreiben
+ * - Tracking-Persistenz: addTrackingEntry → getWeeklyReport → getMonthlyTrend → generateTrackingReport
+ * - Constraint-Validierung im Gesamtfluss
+ *
+ * Requirements: 1.1–1.5, 2.1–2.7, 3.1–3.6, 8.1–8.7
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { mkdtemp, rm, readFile, mkdir, writeFile, readdir } from 'node:fs/promises';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { generateProfileOutput } from './profile-output';
+import { writeContentStrategyOutput } from './strategy-output';
+import { addTrackingEntry, getWeeklyReport, getMonthlyTrend } from './tracking-manager';
+import { generateTrackingReport } from './tracking-output';
+import {
+  validateHeadline,
+  validateAbout,
+  validateExperience,
+  HEADLINE_CHAR_LIMIT,
+  ABOUT_CHAR_LIMIT,
+  EXPERIENCE_CHAR_LIMIT,
+} from './constraints';
+
+describe('LinkedIn Integration Tests', () => {
+  let tempDir: string;
+
+  beforeEach(async () => {
+    tempDir = await mkdtemp(join(tmpdir(), 'linkedin-integration-'));
+
+    // Set up KB structure
+    const profilesDir = join(tempDir, 'kb', 'profiles');
+    const experiencesDir = join(tempDir, 'kb', 'experiences');
+    const organizationsDir = join(tempDir, 'kb', 'organizations');
+    const projectsDir = join(tempDir, 'kb', 'projects');
+    const trackingDir = join(tempDir, 'kb', 'tracking');
+
+    await mkdir(profilesDir, { recursive: true });
+    await mkdir(experiencesDir, { recursive: true });
+    await mkdir(organizationsDir, { recursive: true });
+    await mkdir(projectsDir, { recursive: true });
+    await mkdir(trackingDir, { recursive: true });
+
+    // Person entity
+    await writeFile(
+      join(profilesDir, 'andre-knie.yaml'),
+      [
+        'id: andre-knie',
+        'type: person',
+        'created: 2024-01-01',
+        'modified: 2024-06-01',
+        'name:',
+        '  display: Dr. Andre Knie',
+        '  first: Andre',
+        '  last: Knie',
+        '  title: Dr.',
+        'summary: Experte für KI und Digitalisierung mit 13+ Jahren Erfahrung',
+        'experiences:',
+        '  - db-infrago-digitalisierung',
+        '  - data-hive-cassel-gruender',
+        '  - db-netz-einfachbahn-jobsharing',
+        '  - uni-kassel-doktorand',
+        'education:',
+        '  - degree: Dr. rer. nat.',
+        '    field: Physik',
+        '    institution: Universität Kassel',
+        '    year: 2017',
+        'publications: 60+',
+        'citations: 2000+',
+      ].join('\n'),
+      'utf-8',
+    );
+
+    // Experience: DB InfraGO
+    await writeFile(
+      join(experiencesDir, 'db-infrago-digitalisierung.yaml'),
+      [
+        'id: db-infrago-digitalisierung',
+        'type: experience',
+        'created: 2024-01-01',
+        'modified: 2024-06-01',
+        'title: Experte für Digitalisierung',
+        'organization: db-infrago',
+        'start: 2023-07',
+        'end: null',
+        'description: Verantwortlich für die digitale Transformation der Instandhaltung',
+        'skills-used:',
+        '  - digitale-transformation',
+        '  - change-management',
+        '  - kuenstliche-intelligenz',
+        'achievements:',
+        '  - Digitalisierungsstrategie für 3 Fachbereiche entwickelt',
+        '  - KI-Pilotprojekte initiiert',
+      ].join('\n'),
+      'utf-8',
+    );
+
+    // Experience: Data Hive Cassel
+    await writeFile(
+      join(experiencesDir, 'data-hive-cassel-gruender.yaml'),
+      [
+        'id: data-hive-cassel-gruender',
+        'type: experience',
+        'created: 2024-01-01',
+        'modified: 2024-06-01',
+        'title: Gründer & Geschäftsführer',
+        'organization: data-hive-cassel',
+        'start: 2021-01',
+        'end: null',
+        'description: KI-Beratung und Implementierung für den Mittelstand',
+        'skills-used:',
+        '  - kuenstliche-intelligenz',
+        '  - unternehmensgruendung',
+        '  - beratung',
+        'achievements:',
+        '  - 50+ Projekte erfolgreich umgesetzt',
+        '  - 15+ Kunden betreut',
+        '  - ROI > 2 bei allen Projekten',
+      ].join('\n'),
+      'utf-8',
+    );
+
+    // Experience: DB Netz JobSharing
+    await writeFile(
+      join(experiencesDir, 'db-netz-einfachbahn-jobsharing.yaml'),
+      [
+        'id: db-netz-einfachbahn-jobsharing',
+        'type: experience',
+        'created: 2024-01-01',
+        'modified: 2024-06-01',
+        'title: Leiter EinfachBahn (JobSharing)',
+        'organization: db-netz',
+        'start: 2020-01',
+        'end: 2023-06',
+        'description: Führung im JobSharing-Modell als Innovation in der Führungskultur',
+        'skills-used:',
+        '  - fuehrung',
+        '  - innovation',
+        '  - change-management',
+        'achievements:',
+        '  - Erstes JobSharing-Tandem auf Leitungsebene bei DB Netz',
+        '  - Team von 25 Mitarbeitenden geführt',
+      ].join('\n'),
+      'utf-8',
+    );
+
+    // Experience: Uni Kassel
+    await writeFile(
+      join(experiencesDir, 'uni-kassel-doktorand.yaml'),
+      [
+        'id: uni-kassel-doktorand',
+        'type: experience',
+        'created: 2024-01-01',
+        'modified: 2024-06-01',
+        'title: Wissenschaftlicher Mitarbeiter & Doktorand',
+        'organization: universitaet-kassel',
+        'start: 2012-04',
+        'end: 2017-12',
+        'description: Forschung im Bereich maschinelles Lernen und Physik',
+        'skills-used:',
+        '  - maschinelles-lernen',
+        '  - forschung',
+        '  - lehre',
+        'achievements:',
+        '  - Promotion mit Auszeichnung',
+        '  - 60+ Publikationen',
+        '  - 2000+ Zitationen',
+      ].join('\n'),
+      'utf-8',
+    );
+
+    // Organization: DB InfraGO
+    await writeFile(
+      join(organizationsDir, 'db-infrago.yaml'),
+      [
+        'id: db-infrago',
+        'type: organization',
+        'created: 2024-01-01',
+        'modified: 2024-01-01',
+        'name: DB InfraGO AG',
+        'industry: Schieneninfrastruktur',
+      ].join('\n'),
+      'utf-8',
+    );
+
+    // Organization: Data Hive Cassel
+    await writeFile(
+      join(organizationsDir, 'data-hive-cassel.yaml'),
+      [
+        'id: data-hive-cassel',
+        'type: organization',
+        'created: 2024-01-01',
+        'modified: 2024-01-01',
+        'name: Data Hive Cassel GmbH',
+        'industry: KI-Beratung',
+      ].join('\n'),
+      'utf-8',
+    );
+
+    // Organization: DB Netz
+    await writeFile(
+      join(organizationsDir, 'db-netz.yaml'),
+      [
+        'id: db-netz',
+        'type: organization',
+        'created: 2024-01-01',
+        'modified: 2024-01-01',
+        'name: DB Netz AG',
+        'industry: Schieneninfrastruktur',
+      ].join('\n'),
+      'utf-8',
+    );
+
+    // Organization: Universität Kassel
+    await writeFile(
+      join(organizationsDir, 'universitaet-kassel.yaml'),
+      [
+        'id: universitaet-kassel',
+        'type: organization',
+        'created: 2024-01-01',
+        'modified: 2024-01-01',
+        'name: Universität Kassel',
+        'industry: Hochschule',
+      ].join('\n'),
+      'utf-8',
+    );
+
+    // Project: KI-Beratung
+    await writeFile(
+      join(projectsDir, 'ki-fraitag.yaml'),
+      [
+        'id: ki-fraitag',
+        'type: project',
+        'created: 2024-01-01',
+        'modified: 2024-01-01',
+        'name: KI-FrAItag',
+        'description: Regelmäßiges KI-Format für Wissenstransfer',
+        'organization: data-hive-cassel',
+      ].join('\n'),
+      'utf-8',
+    );
+  });
+
+  afterEach(async () => {
+    await rm(tempDir, { recursive: true, force: true });
+  });
+
+  describe('Profile Output — End-to-End Flow', () => {
+    it('reads KB data, generates all sections, and writes output file', async () => {
+      const result = await generateProfileOutput({
+        personId: 'andre-knie',
+        basePath: tempDir,
+      });
+
+      // Verify result structure
+      expect(result.outputPath).toContain('profile-optimized.md');
+      expect(result.generatedAt).toMatch(/^\d{4}-\d{2}-\d{2}$/);
+      expect(result.sections.headlines.count).toBeGreaterThan(0);
+      expect(result.sections.about.charCount).toBeGreaterThan(0);
+      expect(result.sections.experiences.count).toBeGreaterThan(0);
+
+      // Verify file was actually written to disk
+      const content = await readFile(result.outputPath, 'utf-8');
+      expect(content.length).toBeGreaterThan(0);
+      expect(content).toContain('# LinkedIn-Profil — Optimiert');
+      expect(content).toContain('## Headline');
+      expect(content).toContain('## About Section');
+      expect(content).toContain('## Experience');
+    });
+
+    it('generates multiple headline variants within character limit', async () => {
+      const result = await generateProfileOutput({
+        personId: 'andre-knie',
+        headline: { variants: 3 },
+        basePath: tempDir,
+      });
+
+      const content = await readFile(result.outputPath, 'utf-8');
+
+      // All variants should be present
+      expect(content).toContain('### Variante 1');
+      expect(content).toContain('### Variante 2');
+      expect(content).toContain('### Variante 3');
+      expect(result.sections.headlines.count).toBe(3);
+    });
+
+    it('generates about section with hook and full text', async () => {
+      const result = await generateProfileOutput({
+        personId: 'andre-knie',
+        basePath: tempDir,
+      });
+
+      const content = await readFile(result.outputPath, 'utf-8');
+      expect(content).toContain('### Hook (sichtbar vor "mehr anzeigen")');
+      expect(content).toContain('### Volltext');
+      expect(content).toContain('/2.600 Zeichen');
+    });
+
+    it('generates experience sections for all KB experiences', async () => {
+      const result = await generateProfileOutput({
+        personId: 'andre-knie',
+        basePath: tempDir,
+      });
+
+      // Should have at least the 4 experiences from KB
+      expect(result.sections.experiences.count).toBeGreaterThanOrEqual(2);
+
+      const content = await readFile(result.outputPath, 'utf-8');
+      expect(content).toContain('## Experience');
+    });
+
+    it('includes validation summary in output', async () => {
+      const result = await generateProfileOutput({
+        personId: 'andre-knie',
+        basePath: tempDir,
+      });
+
+      const content = await readFile(result.outputPath, 'utf-8');
+      expect(content).toContain('## Validierung');
+      expect(content).toContain('| Sektion | Status | Details |');
+    });
+  });
+
+  describe('Constraint-Validierung im Gesamtfluss', () => {
+    it('all generated headlines pass constraint validation', async () => {
+      const result = await generateProfileOutput({
+        personId: 'andre-knie',
+        headline: { variants: 3 },
+        basePath: tempDir,
+      });
+
+      expect(result.sections.headlines.valid).toBe(true);
+
+      // Read the output and extract headline texts to validate independently
+      const content = await readFile(result.outputPath, 'utf-8');
+      const headlineMatches = content.match(/### Variante \d+\n\n(.+)\n/g);
+      if (headlineMatches) {
+        for (const match of headlineMatches) {
+          const text = match.split('\n\n')[1]?.trim() ?? '';
+          if (text.length > 0) {
+            const validation = validateHeadline(text);
+            expect(validation.valid).toBe(true);
+            expect(text.length).toBeLessThanOrEqual(HEADLINE_CHAR_LIMIT);
+          }
+        }
+      }
+    });
+
+    it('generated about section passes constraint validation', async () => {
+      const result = await generateProfileOutput({
+        personId: 'andre-knie',
+        basePath: tempDir,
+      });
+
+      expect(result.sections.about.valid).toBe(true);
+      expect(result.sections.about.charCount).toBeLessThanOrEqual(ABOUT_CHAR_LIMIT);
+      expect(result.sections.about.charCount).toBeGreaterThan(0);
+    });
+
+    it('all generated experiences pass constraint validation', async () => {
+      const result = await generateProfileOutput({
+        personId: 'andre-knie',
+        basePath: tempDir,
+      });
+
+      expect(result.sections.experiences.allValid).toBe(true);
+    });
+
+    it('overall validation status is valid or warnings (no errors)', async () => {
+      const result = await generateProfileOutput({
+        personId: 'andre-knie',
+        basePath: tempDir,
+      });
+
+      expect(['valid', 'warnings']).toContain(result.validationStatus);
+    });
+  });
+
+  describe('Content Strategy Output — End-to-End Flow', () => {
+    it('generates content strategy and writes output file', async () => {
+      const markdown = await writeContentStrategyOutput({
+        personId: 'andre-knie',
+        quarter: '2026-Q3',
+        basePath: tempDir,
+      });
+
+      // Verify markdown content
+      expect(markdown).toContain('# Content-Strategie LinkedIn — 2026-Q3');
+      expect(markdown).toContain('## Posting-Frequenz');
+      expect(markdown).toContain('## Themen-Cluster');
+      expect(markdown).toContain('## Wochenplan');
+      expect(markdown).toContain('## Engagement-Routine');
+      expect(markdown).toContain('## Format-Mix');
+
+      // Verify file was written to disk
+      const outputPath = join(tempDir, 'output', 'linkedin', 'content-strategy.md');
+      const fileContent = await readFile(outputPath, 'utf-8');
+      expect(fileContent).toBe(markdown);
+    });
+
+    it('includes all three theme clusters', async () => {
+      const markdown = await writeContentStrategyOutput({
+        personId: 'andre-knie',
+        quarter: '2026-Q3',
+        basePath: tempDir,
+      });
+
+      expect(markdown).toContain('Innovation');
+      expect(markdown).toContain('Mensch');
+      expect(markdown).toContain('Verantwortung');
+    });
+
+    it('includes YAML frontmatter with metadata', async () => {
+      const markdown = await writeContentStrategyOutput({
+        personId: 'andre-knie',
+        quarter: '2026-Q3',
+        basePath: tempDir,
+      });
+
+      expect(markdown).toContain('---');
+      expect(markdown).toContain('quarter: 2026-Q3');
+      expect(markdown).toContain('type: content-strategy');
+    });
+
+    it('passes existing formats to the generator', async () => {
+      const markdown = await writeContentStrategyOutput({
+        personId: 'andre-knie',
+        quarter: '2026-Q3',
+        existingFormats: ['podcast', 'column'],
+        basePath: tempDir,
+      });
+
+      // Should still produce valid output
+      expect(markdown).toContain('# Content-Strategie LinkedIn — 2026-Q3');
+      expect(markdown.length).toBeGreaterThan(100);
+    });
+  });
+
+  describe('Tracking-Persistenz — End-to-End Flow', () => {
+    it('addTrackingEntry persists data as YAML file', async () => {
+      await addTrackingEntry(
+        {
+          id: 'linkedin-2026-w28',
+          type: 'linkedin-tracking',
+          date: '2026-07-13',
+          metrics: {
+            profileViews: 142,
+            searchAppearances: 38,
+            connectionRequests: 12,
+            postImpressions: 4500,
+            engagementRate: 4.2,
+            comments: 23,
+            reposts: 8,
+          },
+          posts: [
+            {
+              title: 'KI in der Bahn — was wirklich funktioniert',
+              date: '2026-07-10',
+              format: 'text',
+              impressions: 2100,
+              engagementRate: 5.1,
+              comments: 14,
+              reposts: 5,
+            },
+            {
+              title: 'Carousel: 5 Fehler bei der KI-Einführung',
+              date: '2026-07-12',
+              format: 'carousel',
+              impressions: 2400,
+              engagementRate: 3.8,
+              comments: 9,
+              reposts: 3,
+            },
+          ],
+        },
+        tempDir,
+      );
+
+      // Verify file was written
+      const trackingDir = join(tempDir, 'kb', 'tracking');
+      const files = await readdir(trackingDir);
+      expect(files).toContain('linkedin-2026-w28.yaml');
+
+      // Verify content is valid YAML with expected data
+      const content = await readFile(join(trackingDir, 'linkedin-2026-w28.yaml'), 'utf-8');
+      expect(content).toContain('linkedin-2026-w28');
+      expect(content).toContain('linkedin-tracking');
+      expect(content).toContain('profile-views');
+      expect(content).toContain('142');
+    });
+
+    it('addTrackingEntry marks best practices automatically', async () => {
+      await addTrackingEntry(
+        {
+          id: 'linkedin-2026-w28',
+          type: 'linkedin-tracking',
+          date: '2026-07-13',
+          metrics: {
+            profileViews: 100,
+            searchAppearances: 30,
+            connectionRequests: 10,
+            postImpressions: 3000,
+            engagementRate: 4.0,
+            comments: 20,
+            reposts: 6,
+          },
+          posts: [
+            {
+              title: 'High Engagement Post',
+              date: '2026-07-10',
+              format: 'text',
+              impressions: 2000,
+              engagementRate: 8.0,
+              comments: 15,
+              reposts: 5,
+            },
+            {
+              title: 'Low Engagement Post',
+              date: '2026-07-11',
+              format: 'carousel',
+              impressions: 1000,
+              engagementRate: 2.0,
+              comments: 3,
+              reposts: 1,
+            },
+          ],
+        },
+        tempDir,
+      );
+
+      const content = await readFile(
+        join(tempDir, 'kb', 'tracking', 'linkedin-2026-w28.yaml'),
+        'utf-8',
+      );
+      // High engagement post should be marked as best practice
+      expect(content).toContain('is-best-practice: true');
+      expect(content).toContain('is-best-practice: false');
+    });
+
+    it('getWeeklyReport aggregates metrics from persisted entries', async () => {
+      // Add tracking entry first
+      await addTrackingEntry(
+        {
+          id: 'linkedin-2026-w28',
+          type: 'linkedin-tracking',
+          date: '2026-07-13',
+          metrics: {
+            profileViews: 142,
+            searchAppearances: 38,
+            connectionRequests: 12,
+            postImpressions: 4500,
+            engagementRate: 4.2,
+            comments: 23,
+            reposts: 8,
+          },
+          posts: [
+            {
+              title: 'Top Post',
+              date: '2026-07-10',
+              format: 'text',
+              impressions: 2100,
+              engagementRate: 5.1,
+              comments: 14,
+              reposts: 5,
+            },
+          ],
+        },
+        tempDir,
+      );
+
+      // Get weekly report
+      const report = await getWeeklyReport('2026-07-13', tempDir);
+
+      expect(report.weekOf).toBe('2026-07-13');
+      expect(report.metrics.profileViews).toBe(142);
+      expect(report.metrics.postImpressions).toBe(4500);
+      expect(report.metrics.engagementRate).toBe(4.2);
+      expect(report.posts.length).toBe(1);
+      expect(report.topPost?.title).toBe('Top Post');
+    });
+
+    it('getMonthlyTrend calculates trends from persisted entries', async () => {
+      // Add two weeks of data
+      await addTrackingEntry(
+        {
+          id: 'linkedin-2026-w27',
+          type: 'linkedin-tracking',
+          date: '2026-07-06',
+          metrics: {
+            profileViews: 100,
+            searchAppearances: 30,
+            connectionRequests: 8,
+            postImpressions: 3000,
+            engagementRate: 3.5,
+            comments: 15,
+            reposts: 5,
+          },
+          posts: [
+            {
+              title: 'Week 27 Post',
+              date: '2026-07-06',
+              format: 'text',
+              impressions: 1500,
+              engagementRate: 3.5,
+              comments: 8,
+              reposts: 3,
+            },
+          ],
+        },
+        tempDir,
+      );
+
+      await addTrackingEntry(
+        {
+          id: 'linkedin-2026-w28',
+          type: 'linkedin-tracking',
+          date: '2026-07-13',
+          metrics: {
+            profileViews: 142,
+            searchAppearances: 38,
+            connectionRequests: 12,
+            postImpressions: 4500,
+            engagementRate: 4.2,
+            comments: 23,
+            reposts: 8,
+          },
+          posts: [
+            {
+              title: 'Week 28 Post',
+              date: '2026-07-13',
+              format: 'carousel',
+              impressions: 2400,
+              engagementRate: 5.0,
+              comments: 12,
+              reposts: 6,
+            },
+          ],
+        },
+        tempDir,
+      );
+
+      const trend = await getMonthlyTrend('2026-07', tempDir);
+
+      expect(trend.month).toBe('2026-07');
+      expect(trend.totalPosts).toBe(2);
+      expect(trend.averageMetrics.profileViews).toBeGreaterThan(0);
+      expect(trend.averageMetrics.postImpressions).toBeGreaterThan(0);
+      expect(trend.recommendations.length).toBeGreaterThan(0);
+    });
+
+    it('full tracking flow: add → weekly → monthly → report', async () => {
+      // Step 1: Add tracking entries
+      await addTrackingEntry(
+        {
+          id: 'linkedin-2026-w28',
+          type: 'linkedin-tracking',
+          date: '2026-07-13',
+          metrics: {
+            profileViews: 142,
+            searchAppearances: 38,
+            connectionRequests: 12,
+            postImpressions: 4500,
+            engagementRate: 4.2,
+            comments: 23,
+            reposts: 8,
+          },
+          posts: [
+            {
+              title: 'KI in der Bahn',
+              date: '2026-07-10',
+              format: 'text',
+              impressions: 2100,
+              engagementRate: 5.1,
+              comments: 14,
+              reposts: 5,
+            },
+            {
+              title: '5 Fehler bei KI-Einführung',
+              date: '2026-07-12',
+              format: 'carousel',
+              impressions: 2400,
+              engagementRate: 3.8,
+              comments: 9,
+              reposts: 3,
+            },
+          ],
+        },
+        tempDir,
+      );
+
+      // Step 2: Verify weekly report
+      const weeklyReport = await getWeeklyReport('2026-07-13', tempDir);
+      expect(weeklyReport.metrics.profileViews).toBe(142);
+      expect(weeklyReport.posts.length).toBe(2);
+
+      // Step 3: Verify monthly trend
+      const monthlyTrend = await getMonthlyTrend('2026-07', tempDir);
+      expect(monthlyTrend.totalPosts).toBe(2);
+      expect(monthlyTrend.month).toBe('2026-07');
+
+      // Step 4: Generate tracking report
+      const outputDir = join(tempDir, 'output', 'linkedin');
+      const reportResult = await generateTrackingReport({
+        weekOf: '2026-07-13',
+        month: '2026-07',
+        basePath: tempDir,
+        outputDir,
+      });
+
+      expect(reportResult.hasWeeklyData).toBe(true);
+      expect(reportResult.hasMonthlyData).toBe(true);
+      expect(reportResult.markdown).toContain('# LinkedIn Tracking Report');
+      expect(reportResult.markdown).toContain('## Wöchentlicher Report');
+      expect(reportResult.markdown).toContain('## Monatliche Trendanalyse');
+      expect(reportResult.markdown).toContain('142');
+      expect(reportResult.markdown).toContain('KI in der Bahn');
+
+      // Verify file was written
+      const fileContent = await readFile(reportResult.filePath, 'utf-8');
+      expect(fileContent).toBe(reportResult.markdown);
+    });
+
+    it('week-over-week changes are calculated correctly', async () => {
+      // Previous week
+      await addTrackingEntry(
+        {
+          id: 'linkedin-2026-w27',
+          type: 'linkedin-tracking',
+          date: '2026-07-06',
+          metrics: {
+            profileViews: 100,
+            searchAppearances: 30,
+            connectionRequests: 8,
+            postImpressions: 3000,
+            engagementRate: 3.0,
+            comments: 15,
+            reposts: 5,
+          },
+          posts: [],
+        },
+        tempDir,
+      );
+
+      // Current week
+      await addTrackingEntry(
+        {
+          id: 'linkedin-2026-w28',
+          type: 'linkedin-tracking',
+          date: '2026-07-13',
+          metrics: {
+            profileViews: 150,
+            searchAppearances: 40,
+            connectionRequests: 12,
+            postImpressions: 4500,
+            engagementRate: 4.5,
+            comments: 25,
+            reposts: 10,
+          },
+          posts: [],
+        },
+        tempDir,
+      );
+
+      const report = await getWeeklyReport('2026-07-13', tempDir);
+
+      // 100 → 150 = +50%
+      expect(report.weekOverWeek.profileViewsChange).toBe(50);
+      // 3000 → 4500 = +50%
+      expect(report.weekOverWeek.impressionsChange).toBe(50);
+      // 3.0 → 4.5 = +50%
+      expect(report.weekOverWeek.engagementRateChange).toBe(50);
+    });
+  });
+});

privat/CV/src/linkedin/profile-output.test.ts

@@ -0,0 +1,227 @@
+/**
+ * Unit tests for LinkedIn Profile Output Generator
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { mkdtemp, rm, readFile, mkdir, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { generateProfileOutput } from './profile-output';
+
+describe('profile-output', () => {
+  let tempDir: string;
+
+  beforeEach(async () => {
+    tempDir = await mkdtemp(join(tmpdir(), 'profile-output-test-'));
+
+    // Set up minimal KB structure for testing
+    const profilesDir = join(tempDir, 'kb', 'profiles');
+    const experiencesDir = join(tempDir, 'kb', 'experiences');
+    const organizationsDir = join(tempDir, 'kb', 'organizations');
+    const projectsDir = join(tempDir, 'kb', 'projects');
+
+    await mkdir(profilesDir, { recursive: true });
+    await mkdir(experiencesDir, { recursive: true });
+    await mkdir(organizationsDir, { recursive: true });
+    await mkdir(projectsDir, { recursive: true });
+
+    // Person entity
+    await writeFile(
+      join(profilesDir, 'andre-knie.yaml'),
+      [
+        'id: andre-knie',
+        'type: person',
+        'created: 2024-01-01',
+        'modified: 2024-01-01',
+        'name:',
+        '  display: Dr. Andre Knie',
+        '  first: Andre',
+        '  last: Knie',
+        '  title: Dr.',
+        'summary: Experte für KI und Digitalisierung',
+        'experiences:',
+        '  - db-infrago-digitalisierung',
+        '  - data-hive-cassel-gruender',
+        'education:',
+        '  - degree: Dr. rer. nat.',
+        '    field: Physik',
+        '    institution: Universität Kassel',
+      ].join('\n'),
+      'utf-8',
+    );
+
+    // Experience: DB InfraGO
+    await writeFile(
+      join(experiencesDir, 'db-infrago-digitalisierung.yaml'),
+      [
+        'id: db-infrago-digitalisierung',
+        'type: experience',
+        'created: 2024-01-01',
+        'modified: 2024-01-01',
+        'title: Experte für Digitalisierung',
+        'organization: db-infrago',
+        'start: 2023-07',
+        'end: null',
+        'skills-used:',
+        '  - digitale-transformation',
+        '  - change-management',
+      ].join('\n'),
+      'utf-8',
+    );
+
+    // Experience: Data Hive Cassel
+    await writeFile(
+      join(experiencesDir, 'data-hive-cassel-gruender.yaml'),
+      [
+        'id: data-hive-cassel-gruender',
+        'type: experience',
+        'created: 2024-01-01',
+        'modified: 2024-01-01',
+        'title: Gründer & Geschäftsführer',
+        'organization: data-hive-cassel',
+        'start: 2021-01',
+        'end: null',
+        'skills-used:',
+        '  - kuenstliche-intelligenz',
+      ].join('\n'),
+      'utf-8',
+    );
+
+    // Organization: DB InfraGO
+    await writeFile(
+      join(organizationsDir, 'db-infrago.yaml'),
+      [
+        'id: db-infrago',
+        'type: organization',
+        'created: 2024-01-01',
+        'modified: 2024-01-01',
+        'name: DB InfraGO AG',
+      ].join('\n'),
+      'utf-8',
+    );
+
+    // Organization: Data Hive Cassel
+    await writeFile(
+      join(organizationsDir, 'data-hive-cassel.yaml'),
+      [
+        'id: data-hive-cassel',
+        'type: organization',
+        'created: 2024-01-01',
+        'modified: 2024-01-01',
+        'name: Data Hive Cassel GmbH',
+      ].join('\n'),
+      'utf-8',
+    );
+  });
+
+  afterEach(async () => {
+    await rm(tempDir, { recursive: true, force: true });
+  });
+
+  it('generates profile-optimized.md with all sections', async () => {
+    const result = await generateProfileOutput({
+      personId: 'andre-knie',
+      basePath: tempDir,
+    });
+
+    expect(result.outputPath).toContain('profile-optimized.md');
+    expect(result.generatedAt).toMatch(/^\d{4}-\d{2}-\d{2}$/);
+    expect(result.sections.headlines.count).toBeGreaterThan(0);
+    expect(result.sections.about.charCount).toBeGreaterThan(0);
+    expect(result.sections.experiences.count).toBeGreaterThan(0);
+
+    // Verify file was written
+    const content = await readFile(result.outputPath, 'utf-8');
+    expect(content).toContain('# LinkedIn-Profil — Optimiert');
+    expect(content).toContain('Generated:');
+    expect(content).toContain('## Headline');
+    expect(content).toContain('## About Section');
+    expect(content).toContain('## Experience');
+    expect(content).toContain('## Validierung');
+  });
+
+  it('includes generation date in output', async () => {
+    const result = await generateProfileOutput({
+      personId: 'andre-knie',
+      basePath: tempDir,
+    });
+
+    const content = await readFile(result.outputPath, 'utf-8');
+    const today = new Date().toISOString().split('T')[0];
+    expect(content).toContain(`Generated: ${today}`);
+  });
+
+  it('includes validation status in output', async () => {
+    const result = await generateProfileOutput({
+      personId: 'andre-knie',
+      basePath: tempDir,
+    });
+
+    const content = await readFile(result.outputPath, 'utf-8');
+    expect(content).toContain('Validation:');
+    // Should have a validation summary table
+    expect(content).toContain('| Sektion | Status | Details |');
+  });
+
+  it('returns valid validation status when all constraints pass', async () => {
+    const result = await generateProfileOutput({
+      personId: 'andre-knie',
+      basePath: tempDir,
+    });
+
+    // All generated content should be within limits
+    expect(['valid', 'warnings']).toContain(result.validationStatus);
+    expect(result.sections.headlines.valid).toBe(true);
+    expect(result.sections.about.valid).toBe(true);
+    expect(result.sections.experiences.allValid).toBe(true);
+  });
+
+  it('creates output directory if it does not exist', async () => {
+    const result = await generateProfileOutput({
+      personId: 'andre-knie',
+      basePath: tempDir,
+    });
+
+    // File should exist at the expected path
+    const content = await readFile(result.outputPath, 'utf-8');
+    expect(content.length).toBeGreaterThan(0);
+  });
+
+  it('includes headline variants with character counts', async () => {
+    const result = await generateProfileOutput({
+      personId: 'andre-knie',
+      headline: { variants: 2 },
+      basePath: tempDir,
+    });
+
+    const content = await readFile(result.outputPath, 'utf-8');
+    expect(content).toContain('### Variante 1');
+    expect(content).toContain('### Variante 2');
+    expect(content).toContain('/220 Zeichen');
+    expect(result.sections.headlines.count).toBe(2);
+  });
+
+  it('includes about section with hook preview', async () => {
+    const result = await generateProfileOutput({
+      personId: 'andre-knie',
+      basePath: tempDir,
+    });
+
+    const content = await readFile(result.outputPath, 'utf-8');
+    expect(content).toContain('### Hook (sichtbar vor "mehr anzeigen")');
+    expect(content).toContain('### Volltext');
+    expect(content).toContain('/2.600 Zeichen');
+  });
+
+  it('includes experience sections with achievements', async () => {
+    const result = await generateProfileOutput({
+      personId: 'andre-knie',
+      basePath: tempDir,
+    });
+
+    const content = await readFile(result.outputPath, 'utf-8');
+    // Should contain experience entries
+    expect(content).toContain('## Experience');
+    expect(result.sections.experiences.count).toBeGreaterThanOrEqual(2);
+  });
+});

privat/CV/src/linkedin/profile-output.ts

@@ -0,0 +1,251 @@
+/**
+ * LinkedIn Profile Output Generator
+ *
+ * Combines headline, about, and experience generators into a single
+ * Markdown document written to output/linkedin/profile-optimized.md.
+ * Includes generation date and validation status for each section.
+ */
+
+import { writeFile, mkdir } from 'node:fs/promises';
+import { join } from 'node:path';
+import { generateHeadlines } from './headline-generator';
+import { generateAbout } from './about-generator';
+import { generateExperiences } from './experience-generator';
+import type { HeadlineOptions, AboutOptions, ExperienceOptions } from './types';
+import type { ConstraintValidation } from './constraints';
+
+// --- Public Interface ---
+
+export interface ProfileOutputOptions {
+  /** Person entity ID */
+  personId: string;
+  /** Headline generation options */
+  headline?: Omit<HeadlineOptions, 'personId'>;
+  /** About section generation options */
+  about?: Omit<AboutOptions, 'personId'>;
+  /** Experience generation options */
+  experience?: Omit<ExperienceOptions, 'personId'>;
+  /** Base path for output directory (default: process.cwd()) */
+  basePath?: string;
+}
+
+export interface ProfileOutputResult {
+  /** Path to the written output file */
+  outputPath: string;
+  /** ISO date string of generation */
+  generatedAt: string;
+  /** Overall validation status */
+  validationStatus: 'valid' | 'warnings' | 'errors';
+  /** Section-level validation details */
+  sections: {
+    headlines: { count: number; valid: boolean };
+    about: { charCount: number; valid: boolean };
+    experiences: { count: number; allValid: boolean };
+  };
+}
+
+// --- Constants ---
+
+const OUTPUT_DIR = 'output/linkedin';
+const OUTPUT_FILE = 'profile-optimized.md';
+
+// --- Public API ---
+
+/**
+ * Generates the complete LinkedIn profile document and writes it to disk.
+ *
+ * Calls headline, about, and experience generators, assembles the results
+ * into a structured Markdown document, and writes to output/linkedin/profile-optimized.md.
+ */
+export async function generateProfileOutput(options: ProfileOutputOptions): Promise<ProfileOutputResult> {
+  const { personId, basePath = process.cwd() } = options;
+  const generatedAt = new Date().toISOString().split('T')[0];
+
+  // Generate all sections
+  const headlineResult = await generateHeadlines({
+    personId,
+    emphasis: options.headline?.emphasis,
+    variants: options.headline?.variants,
+  });
+
+  const aboutResult = await generateAbout({
+    personId,
+    tone: options.about?.tone,
+    includeStats: options.about?.includeStats,
+  });
+
+  const experienceResults = await generateExperiences({
+    personId,
+    experienceIds: options.experience?.experienceIds,
+    keywords: options.experience?.keywords,
+  });
+
+  // Determine overall validation status
+  const allValidations: ConstraintValidation[] = [
+    headlineResult.validation,
+    aboutResult.validation,
+    ...experienceResults.map((e) => e.validation),
+  ];
+
+  const hasErrors = allValidations.some((v) => !v.valid);
+  const hasWarnings = allValidations.some((v) => v.warnings.length > 0);
+  const validationStatus = hasErrors ? 'errors' : hasWarnings ? 'warnings' : 'valid';
+
+  // Assemble Markdown document
+  const markdown = assembleMarkdown({
+    generatedAt,
+    validationStatus,
+    headlineResult,
+    aboutResult,
+    experienceResults,
+  });
+
+  // Write to disk
+  const outputDir = join(basePath, OUTPUT_DIR);
+  await mkdir(outputDir, { recursive: true });
+  const outputPath = join(outputDir, OUTPUT_FILE);
+  await writeFile(outputPath, markdown, 'utf-8');
+
+  return {
+    outputPath,
+    generatedAt,
+    validationStatus,
+    sections: {
+      headlines: {
+        count: headlineResult.variants.length,
+        valid: headlineResult.validation.valid,
+      },
+      about: {
+        charCount: aboutResult.charCount,
+        valid: aboutResult.validation.valid,
+      },
+      experiences: {
+        count: experienceResults.length,
+        allValid: experienceResults.every((e) => e.validation.valid),
+      },
+    },
+  };
+}
+
+// --- Markdown Assembly ---
+
+interface AssemblyInput {
+  generatedAt: string;
+  validationStatus: 'valid' | 'warnings' | 'errors';
+  headlineResult: Awaited<ReturnType<typeof generateHeadlines>>;
+  aboutResult: Awaited<ReturnType<typeof generateAbout>>;
+  experienceResults: Awaited<ReturnType<typeof generateExperiences>>;
+}
+
+function assembleMarkdown(input: AssemblyInput): string {
+  const { generatedAt, validationStatus, headlineResult, aboutResult, experienceResults } = input;
+
+  const sections: string[] = [];
+
+  // Header
+  sections.push(`# LinkedIn-Profil — Optimiert`);
+  sections.push('');
+  sections.push(`> Generated: ${generatedAt} | Validation: ${formatValidationStatus(validationStatus)}`);
+  sections.push('');
+  sections.push('---');
+  sections.push('');
+
+  // Headlines
+  sections.push('## Headline');
+  sections.push('');
+  for (let i = 0; i < headlineResult.variants.length; i++) {
+    const variant = headlineResult.variants[i];
+    sections.push(`### Variante ${i + 1}`);
+    sections.push('');
+    sections.push(variant.text);
+    sections.push('');
+    sections.push(`*${variant.charCount}/220 Zeichen | Keywords: ${variant.keywords.join(', ') || '—'}*`);
+    sections.push('');
+  }
+
+  sections.push('---');
+  sections.push('');
+
+  // About Section
+  sections.push('## About Section');
+  sections.push('');
+  sections.push(`*${aboutResult.charCount}/2.600 Zeichen | Validation: ${aboutResult.validation.valid ? '✅' : '❌'}*`);
+  sections.push('');
+  sections.push('### Hook (sichtbar vor "mehr anzeigen")');
+  sections.push('');
+  sections.push(aboutResult.hookPreview);
+  sections.push('');
+  sections.push('### Volltext');
+  sections.push('');
+  sections.push(aboutResult.fullText);
+  sections.push('');
+
+  sections.push('---');
+  sections.push('');
+
+  // Experience Sections
+  sections.push('## Experience');
+  sections.push('');
+
+  for (const exp of experienceResults) {
+    sections.push(`### ${exp.title} — ${exp.organization}`);
+    sections.push('');
+    sections.push(`*Validation: ${exp.validation.valid ? '✅' : '❌'} | Keywords: ${exp.keywords.slice(0, 5).join(', ')}*`);
+    sections.push('');
+    sections.push(exp.description);
+    sections.push('');
+
+    if (exp.achievements.length > 0) {
+      sections.push('**Achievements:**');
+      for (const achievement of exp.achievements) {
+        sections.push(`- ${achievement}`);
+      }
+      sections.push('');
+    }
+  }
+
+  sections.push('---');
+  sections.push('');
+
+  // Validation Summary
+  sections.push('## Validierung');
+  sections.push('');
+  sections.push(`| Sektion | Status | Details |`);
+  sections.push(`|---------|--------|---------|`);
+  sections.push(`| Headline | ${headlineResult.validation.valid ? '✅' : '❌'} | ${headlineResult.variants.length} Varianten generiert |`);
+  sections.push(`| About | ${aboutResult.validation.valid ? '✅' : '❌'} | ${aboutResult.charCount}/2.600 Zeichen |`);
+  sections.push(`| Experience | ${experienceResults.every((e) => e.validation.valid) ? '✅' : '❌'} | ${experienceResults.length} Positionen generiert |`);
+  sections.push('');
+
+  if (headlineResult.validation.warnings.length > 0 || aboutResult.validation.warnings.length > 0) {
+    sections.push('### Warnungen');
+    sections.push('');
+    for (const w of headlineResult.validation.warnings) {
+      sections.push(`- Headline: ${w.message}`);
+    }
+    for (const w of aboutResult.validation.warnings) {
+      sections.push(`- About: ${w.message}`);
+    }
+    for (const exp of experienceResults) {
+      for (const w of exp.validation.warnings) {
+        sections.push(`- Experience (${exp.title}): ${w.message}`);
+      }
+    }
+    sections.push('');
+  }
+
+  return sections.join('\n');
+}
+
+// --- Helpers ---
+
+function formatValidationStatus(status: 'valid' | 'warnings' | 'errors'): string {
+  switch (status) {
+    case 'valid':
+      return '✅ Alle Constraints erfüllt';
+    case 'warnings':
+      return '⚠️ Warnungen vorhanden';
+    case 'errors':
+      return '❌ Constraint-Verletzungen';
+  }
+}

privat/CV/src/linkedin/strategy-output.test.ts

@@ -0,0 +1,152 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { formatStrategyMarkdown, writeContentStrategyOutput } from './strategy-output';
+import type { ContentStrategy } from './types';
+
+// Mock fs and content-strategy module
+vi.mock('node:fs/promises', () => ({
+  writeFile: vi.fn().mockResolvedValue(undefined),
+  mkdir: vi.fn().mockResolvedValue(undefined),
+}));
+
+vi.mock('./content-strategy', () => ({
+  generateContentStrategy: vi.fn().mockResolvedValue({
+    postingFrequency: '2 Beiträge pro Woche',
+    themeCluster: [
+      { name: 'Innovation & Technologie', weight: 40, topics: ['KI-Anwendungen', 'Digitalisierung'] },
+      { name: 'Mensch & Kultur', weight: 35, topics: ['Change Management', 'Führung'] },
+      { name: 'Verantwortung', weight: 25, topics: ['Ethik in der KI'] },
+    ],
+    weeklyPlan: [
+      { day: 'Dienstag', time: '08:00', format: 'Text', themeCluster: 'Innovation & Technologie' },
+      { day: 'Donnerstag', time: '08:00', format: 'Carousel', themeCluster: 'Mensch & Kultur' },
+    ],
+    engagementRoutine: {
+      commentsPerWeek: 5,
+      targetAccounts: ['KI-Thought-Leader DACH', 'Startup-Gründer'],
+      dailyTimeMinutes: 15,
+    },
+    formatMix: { text: 40, carousel: 30, video: 15, newsletter: 15 },
+  } satisfies ContentStrategy),
+}));
+
+describe('strategy-output', () => {
+  const mockStrategy: ContentStrategy = {
+    postingFrequency: '2 Beiträge pro Woche',
+    themeCluster: [
+      { name: 'Innovation & Technologie', weight: 40, topics: ['KI-Anwendungen', 'Digitalisierung'] },
+      { name: 'Mensch & Kultur', weight: 35, topics: ['Change Management', 'Führung'] },
+      { name: 'Verantwortung', weight: 25, topics: ['Ethik in der KI'] },
+    ],
+    weeklyPlan: [
+      { day: 'Dienstag', time: '08:00', format: 'Text', themeCluster: 'Innovation & Technologie' },
+      { day: 'Donnerstag', time: '08:00', format: 'Carousel', themeCluster: 'Mensch & Kultur' },
+    ],
+    engagementRoutine: {
+      commentsPerWeek: 5,
+      targetAccounts: ['KI-Thought-Leader DACH', 'Startup-Gründer'],
+      dailyTimeMinutes: 15,
+    },
+    formatMix: { text: 40, carousel: 30, video: 15, newsletter: 15 },
+  };
+
+  describe('formatStrategyMarkdown', () => {
+    it('includes YAML frontmatter with quarter and generation date', () => {
+      const md = formatStrategyMarkdown(mockStrategy, '2026-Q3');
+      expect(md).toContain('---');
+      expect(md).toContain('quarter: 2026-Q3');
+      expect(md).toContain('type: content-strategy');
+      expect(md).toMatch(/generated: \d{4}-\d{2}-\d{2}/);
+    });
+
+    it('includes the quarter in the title', () => {
+      const md = formatStrategyMarkdown(mockStrategy, '2026-Q3');
+      expect(md).toContain('# Content-Strategie LinkedIn — 2026-Q3');
+    });
+
+    it('includes posting frequency section', () => {
+      const md = formatStrategyMarkdown(mockStrategy, '2026-Q3');
+      expect(md).toContain('## Posting-Frequenz');
+      expect(md).toContain('2 Beiträge pro Woche');
+    });
+
+    it('includes all theme clusters with weights and topics', () => {
+      const md = formatStrategyMarkdown(mockStrategy, '2026-Q3');
+      expect(md).toContain('### Innovation & Technologie (40%)');
+      expect(md).toContain('### Mensch & Kultur (35%)');
+      expect(md).toContain('### Verantwortung (25%)');
+      expect(md).toContain('- KI-Anwendungen');
+      expect(md).toContain('- Digitalisierung');
+      expect(md).toContain('- Change Management');
+      expect(md).toContain('- Ethik in der KI');
+    });
+
+    it('includes weekly plan as a table', () => {
+      const md = formatStrategyMarkdown(mockStrategy, '2026-Q3');
+      expect(md).toContain('## Wochenplan');
+      expect(md).toContain('| Tag | Uhrzeit | Format | Themen-Cluster |');
+      expect(md).toContain('| Dienstag | 08:00 | Text | Innovation & Technologie |');
+      expect(md).toContain('| Donnerstag | 08:00 | Carousel | Mensch & Kultur |');
+    });
+
+    it('includes engagement routine', () => {
+      const md = formatStrategyMarkdown(mockStrategy, '2026-Q3');
+      expect(md).toContain('## Engagement-Routine');
+      expect(md).toContain('5+');
+      expect(md).toContain('15 Minuten');
+      expect(md).toContain('- KI-Thought-Leader DACH');
+      expect(md).toContain('- Startup-Gründer');
+    });
+
+    it('includes format mix with percentages', () => {
+      const md = formatStrategyMarkdown(mockStrategy, '2026-Q3');
+      expect(md).toContain('## Format-Mix');
+      expect(md).toContain('- Text: 40%');
+      expect(md).toContain('- Carousel: 30%');
+      expect(md).toContain('- Video: 15%');
+      expect(md).toContain('- Newsletter: 15%');
+    });
+  });
+
+  describe('writeContentStrategyOutput', () => {
+    it('calls generateContentStrategy and writes output file', async () => {
+      const { writeFile, mkdir } = await import('node:fs/promises');
+      const { generateContentStrategy } = await import('./content-strategy');
+
+      const result = await writeContentStrategyOutput({
+        personId: 'andre-knie',
+        quarter: '2026-Q3',
+        basePath: '/test',
+      });
+
+      expect(generateContentStrategy).toHaveBeenCalledWith({
+        personId: 'andre-knie',
+        quarter: '2026-Q3',
+        existingFormats: undefined,
+      });
+      expect(mkdir).toHaveBeenCalled();
+      expect(writeFile).toHaveBeenCalledWith(
+        expect.stringContaining('content-strategy.md'),
+        expect.any(String),
+        'utf-8'
+      );
+      expect(result).toContain('# Content-Strategie LinkedIn — 2026-Q3');
+    });
+
+    it('passes existingFormats to the generator', async () => {
+      const { generateContentStrategy } = await import('./content-strategy');
+
+      await writeContentStrategyOutput({
+        personId: 'andre-knie',
+        quarter: '2026-Q3',
+        existingFormats: ['podcast', 'column'],
+        basePath: '/test',
+      });
+
+      expect(generateContentStrategy).toHaveBeenCalledWith({
+        personId: 'andre-knie',
+        quarter: '2026-Q3',
+        existingFormats: ['podcast', 'column'],
+      });
+    });
+  });
+});

privat/CV/src/linkedin/strategy-output.ts

@@ -0,0 +1,132 @@
+/**
+ * LinkedIn Content Strategy Output Generator
+ *
+ * Calls the content strategy generator and formats the result
+ * as a structured Markdown document written to output/linkedin/content-strategy.md.
+ * Includes generation date and quarter info.
+ */
+
+import { writeFile, mkdir } from 'node:fs/promises';
+import { join } from 'node:path';
+import { generateContentStrategy } from './content-strategy';
+import type { ContentStrategy, ContentStrategyOptions, ThemeCluster, WeeklySlot } from './types';
+
+export interface StrategyOutputOptions {
+  personId: string;
+  quarter: string;
+  existingFormats?: string[];
+  basePath?: string;
+}
+
+/**
+ * Generates the content strategy and writes it to output/linkedin/content-strategy.md.
+ * Returns the generated markdown string.
+ */
+export async function writeContentStrategyOutput(options: StrategyOutputOptions): Promise<string> {
+  const { personId, quarter, existingFormats, basePath = process.cwd() } = options;
+
+  const strategyOptions: ContentStrategyOptions = { personId, quarter, existingFormats };
+  const strategy = await generateContentStrategy(strategyOptions);
+
+  const markdown = formatStrategyMarkdown(strategy, quarter);
+
+  const outputDir = join(basePath, 'output', 'linkedin');
+  await mkdir(outputDir, { recursive: true });
+  const outputPath = join(outputDir, 'content-strategy.md');
+  await writeFile(outputPath, markdown, 'utf-8');
+
+  return markdown;
+}
+
+/**
+ * Formats a ContentStrategy into a structured Markdown document.
+ */
+export function formatStrategyMarkdown(strategy: ContentStrategy, quarter: string): string {
+  const generatedDate = new Date().toISOString().slice(0, 10);
+  const sections: string[] = [];
+
+  // Frontmatter
+  sections.push(
+    [
+      '---',
+      `generated: ${generatedDate}`,
+      `quarter: ${quarter}`,
+      'type: content-strategy',
+      '---',
+    ].join('\n')
+  );
+
+  // Title
+  sections.push(`# Content-Strategie LinkedIn — ${quarter}\n\nGeneriert: ${generatedDate}`);
+
+  // Posting-Frequenz
+  sections.push(`## Posting-Frequenz\n\n${strategy.postingFrequency}`);
+
+  // Themen-Cluster
+  sections.push(formatThemeClusters(strategy.themeCluster));
+
+  // Wochenplan
+  sections.push(formatWeeklyPlan(strategy.weeklyPlan));
+
+  // Engagement-Routine
+  sections.push(formatEngagementRoutine(strategy.engagementRoutine));
+
+  // Format-Mix
+  sections.push(formatFormatMix(strategy.formatMix));
+
+  return sections.join('\n\n') + '\n';
+}
+
+function formatThemeClusters(clusters: ThemeCluster[]): string {
+  const lines: string[] = ['## Themen-Cluster'];
+
+  for (const cluster of clusters) {
+    lines.push('');
+    lines.push(`### ${cluster.name} (${cluster.weight}%)`);
+    lines.push('');
+    for (const topic of cluster.topics) {
+      lines.push(`- ${topic}`);
+    }
+  }
+
+  return lines.join('\n');
+}
+
+function formatWeeklyPlan(slots: WeeklySlot[]): string {
+  const lines: string[] = ['## Wochenplan'];
+  lines.push('');
+  lines.push('| Tag | Uhrzeit | Format | Themen-Cluster |');
+  lines.push('|-----|---------|--------|----------------|');
+
+  for (const slot of slots) {
+    lines.push(`| ${slot.day} | ${slot.time} | ${slot.format} | ${slot.themeCluster} |`);
+  }
+
+  return lines.join('\n');
+}
+
+function formatEngagementRoutine(routine: ContentStrategy['engagementRoutine']): string {
+  const lines: string[] = ['## Engagement-Routine'];
+  lines.push('');
+  lines.push(`- **Kommentare pro Woche:** ${routine.commentsPerWeek}+`);
+  lines.push(`- **Tägliche Investition:** ${routine.dailyTimeMinutes} Minuten`);
+  lines.push('');
+  lines.push('**Ziel-Accounts:**');
+  lines.push('');
+  for (const account of routine.targetAccounts) {
+    lines.push(`- ${account}`);
+  }
+
+  return lines.join('\n');
+}
+
+function formatFormatMix(mix: ContentStrategy['formatMix']): string {
+  const lines: string[] = ['## Format-Mix'];
+  lines.push('');
+  lines.push(`- Text: ${mix.text}%`);
+  lines.push(`- Carousel: ${mix.carousel}%`);
+  lines.push(`- Video: ${mix.video}%`);
+  lines.push(`- Newsletter: ${mix.newsletter}%`);
+
+  return lines.join('\n');
+}

privat/CV/src/linkedin/tracking-manager.test.ts

@@ -0,0 +1,269 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { mkdtemp, rm, readFile, mkdir, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { stringify, parse } from 'yaml';
+import { addTrackingEntry, getWeeklyReport, getMonthlyTrend } from './tracking-manager';
+import type { TrackingEntry } from './types';
+
+// --- Test Helpers ---
+
+let tempDir: string;
+
+beforeEach(async () => {
+  tempDir = await mkdtemp(join(tmpdir(), 'tracking-test-'));
+});
+
+afterEach(async () => {
+  await rm(tempDir, { recursive: true, force: true });
+});
+
+function makeEntry(overrides: Partial<TrackingEntry> = {}): TrackingEntry {
+  return {
+    id: 'linkedin-2026-w28',
+    type: 'linkedin-tracking',
+    date: '2026-07-13',
+    metrics: {
+      profileViews: 142,
+      searchAppearances: 38,
+      connectionRequests: 12,
+      postImpressions: 4500,
+      engagementRate: 4.2,
+      comments: 23,
+      reposts: 8,
+    },
+    posts: [
+      {
+        title: 'KI in der Bahn — was wirklich funktioniert',
+        date: '2026-07-10',
+        format: 'text',
+        impressions: 2100,
+        engagementRate: 5.1,
+        comments: 14,
+        reposts: 5,
+      },
+      {
+        title: 'Carousel: 5 Fehler bei der KI-Einführung',
+        date: '2026-07-12',
+        format: 'carousel',
+        impressions: 2400,
+        engagementRate: 3.8,
+        comments: 9,
+        reposts: 3,
+      },
+    ],
+    ...overrides,
+  };
+}
+
+
+// --- YAML Serialization/Deserialization ---
+
+describe('YAML Serialisierung/Deserialisierung', () => {
+  it('writes a tracking entry as YAML and reads it back with correct data', async () => {
+    const entry = makeEntry();
+    await addTrackingEntry(entry, tempDir);
+
+    const filePath = join(tempDir, 'kb', 'tracking', `${entry.id}.yaml`);
+    const content = await readFile(filePath, 'utf-8');
+    const parsed = parse(content);
+
+    // YAML uses kebab-case keys
+    expect(parsed.id).toBe('linkedin-2026-w28');
+    expect(parsed.type).toBe('linkedin-tracking');
+    expect(parsed.date).toBe('2026-07-13');
+    expect(parsed.metrics['profile-views']).toBe(142);
+    expect(parsed.metrics['search-appearances']).toBe(38);
+    expect(parsed.metrics['connection-requests']).toBe(12);
+    expect(parsed.metrics['post-impressions']).toBe(4500);
+    expect(parsed.metrics['engagement-rate']).toBe(4.2);
+  });
+
+  it('preserves post data through serialization round-trip', async () => {
+    const entry = makeEntry();
+    await addTrackingEntry(entry, tempDir);
+
+    const filePath = join(tempDir, 'kb', 'tracking', `${entry.id}.yaml`);
+    const content = await readFile(filePath, 'utf-8');
+    const parsed = parse(content);
+
+    expect(parsed.posts).toHaveLength(2);
+    expect(parsed.posts[0].title).toBe('KI in der Bahn — was wirklich funktioniert');
+    expect(parsed.posts[0].format).toBe('text');
+    expect(parsed.posts[0].impressions).toBe(2100);
+    expect(parsed.posts[0]['engagement-rate']).toBe(5.1);
+  });
+
+  it('creates kb/tracking/ directory if it does not exist', async () => {
+    const entry = makeEntry();
+    await addTrackingEntry(entry, tempDir);
+
+    const filePath = join(tempDir, 'kb', 'tracking', `${entry.id}.yaml`);
+    const content = await readFile(filePath, 'utf-8');
+    expect(content).toBeTruthy();
+  });
+
+  it('handles entry without posts', async () => {
+    const entry = makeEntry({ posts: undefined });
+    await addTrackingEntry(entry, tempDir);
+
+    const filePath = join(tempDir, 'kb', 'tracking', `${entry.id}.yaml`);
+    const content = await readFile(filePath, 'utf-8');
+    const parsed = parse(content);
+
+    expect(parsed.posts).toBeUndefined();
+    expect(parsed.metrics['profile-views']).toBe(142);
+  });
+});
+
+// --- Weekly Report Aggregation ---
+
+describe('Weekly-Report-Aggregation', () => {
+  it('aggregates metrics from multiple entries in a week', async () => {
+    const trackingDir = join(tempDir, 'kb', 'tracking');
+    await mkdir(trackingDir, { recursive: true });
+
+    // Two entries in the same week (week of 2026-07-13)
+    const entry1 = makeEntry({
+      id: 'linkedin-2026-w28-a',
+      date: '2026-07-13',
+      metrics: {
+        profileViews: 100,
+        searchAppearances: 20,
+        connectionRequests: 5,
+        postImpressions: 2000,
+        engagementRate: 4.0,
+        comments: 10,
+        reposts: 3,
+      },
+      posts: [],
+    });
+    const entry2 = makeEntry({
+      id: 'linkedin-2026-w28-b',
+      date: '2026-07-15',
+      metrics: {
+        profileViews: 50,
+        searchAppearances: 10,
+        connectionRequests: 3,
+        postImpressions: 1500,
+        engagementRate: 5.0,
+        comments: 8,
+        reposts: 2,
+      },
+      posts: [],
+    });
+
+    await addTrackingEntry(entry1, tempDir);
+    await addTrackingEntry(entry2, tempDir);
+
+    const report = await getWeeklyReport('2026-07-13', tempDir);
+
+    expect(report.weekOf).toBe('2026-07-13');
+    expect(report.metrics.profileViews).toBe(150); // 100 + 50
+    expect(report.metrics.searchAppearances).toBe(30); // 20 + 10
+    expect(report.metrics.connectionRequests).toBe(8); // 5 + 3
+    expect(report.metrics.postImpressions).toBe(3500); // 2000 + 1500
+    expect(report.metrics.comments).toBe(18); // 10 + 8
+    expect(report.metrics.reposts).toBe(5); // 3 + 2
+    // engagementRate is averaged
+    expect(report.metrics.engagementRate).toBe(4.5); // (4.0 + 5.0) / 2
+  });
+
+  it('identifies the top post by engagement rate', async () => {
+    const entry = makeEntry({
+      id: 'linkedin-2026-w28',
+      date: '2026-07-14',
+      posts: [
+        {
+          title: 'Low performer',
+          date: '2026-07-14',
+          format: 'text',
+          impressions: 500,
+          engagementRate: 2.0,
+          comments: 3,
+          reposts: 1,
+        },
+        {
+          title: 'Top performer',
+          date: '2026-07-15',
+          format: 'carousel',
+          impressions: 3000,
+          engagementRate: 7.5,
+          comments: 20,
+          reposts: 10,
+        },
+      ],
+    });
+
+    await addTrackingEntry(entry, tempDir);
+    const report = await getWeeklyReport('2026-07-13', tempDir);
+
+    expect(report.topPost).toBeDefined();
+    expect(report.topPost!.title).toBe('Top performer');
+    expect(report.topPost!.engagementRate).toBe(7.5);
+  });
+
+  it('calculates week-over-week changes', async () => {
+    // Previous week entry
+    const prevEntry = makeEntry({
+      id: 'linkedin-2026-w27',
+      date: '2026-07-06',
+      metrics: {
+        profileViews: 100,
+        searchAppearances: 20,
+        connectionRequests: 5,
+        postImpressions: 2000,
+        engagementRate: 4.0,
+        comments: 10,
+        reposts: 3,
+      },
+      posts: [],
+    });
+
+    // Current week entry
+    const currEntry = makeEntry({
+      id: 'linkedin-2026-w28',
+      date: '2026-07-13',
+      metrics: {
+        profileViews: 150,
+        searchAppearances: 30,
+        connectionRequests: 8,
+        postImpressions: 3000,
+        engagementRate: 5.0,
+        comments: 15,
+        reposts: 5,
+      },
+      posts: [],
+    });
+
+    await addTrackingEntry(prevEntry, tempDir);
+    await addTrackingEntry(currEntry, tempDir);
+
+    const report = await getWeeklyReport('2026-07-13', tempDir);
+
+    // profileViews: (150 - 100) / 100 * 100 = 50%
+    expect(report.weekOverWeek.profileViewsChange).toBe(50);
+    // impressions: (3000 - 2000) / 2000 * 100 = 50%
+    expect(report.weekOverWeek.impressionsChange).toBe(50);
+    // engagementRate: (5.0 - 4.0) / 4.0 * 100 = 25%
+    expect(report.weekOverWeek.engagementRateChange).toBe(25);
+  });
+
+  it('returns zero changes when no previous week data exists', async () => {
+    const entry = makeEntry({
+      id: 'linkedin-2026-w28',
+      date: '2026-07-13',
+      posts: [],
+    });
+
+    await addTrackingEntry(entry, tempDir);
+    const report = await getWeeklyReport('2026-07-13', tempDir);
+
+    // No previous week → previous metrics are all 0
+    // calculateChange(0, current) → 100 when current > 0
+    expect(report.weekOverWeek.profileViewsChange).toBe(100);
+    expect(report.weekOverWeek.impressionsChange).toBe(100);
+    expect(report.weekOverWeek.engagementRateChange).toBe(100);
+  });
+});
+

privat/CV/src/linkedin/tracking-manager.ts

@@ -0,0 +1,384 @@
+/**
+ * LinkedIn Tracking Manager
+ *
+ * Manages LinkedIn metrics as YAML entities in kb/tracking/.
+ * Provides functions to add tracking entries, generate weekly reports,
+ * and calculate monthly trends with best-practice marking and
+ * content optimization recommendations.
+ */
+
+import { readFile, writeFile, readdir, mkdir } from 'node:fs/promises';
+import { join } from 'node:path';
+import { stringify, parse } from 'yaml';
+import type { TrackingEntry, PostMetric, WeeklyReport, MonthlyTrend } from './types';
+
+// --- Key Mapping (camelCase ↔ kebab-case) ---
+
+const TRACKING_CAMEL_TO_KEBAB: Record<string, string> = {
+  profileViews: 'profile-views',
+  searchAppearances: 'search-appearances',
+  connectionRequests: 'connection-requests',
+  postImpressions: 'post-impressions',
+  engagementRate: 'engagement-rate',
+  isBestPractice: 'is-best-practice',
+};
+
+const TRACKING_KEBAB_TO_CAMEL: Record<string, string> = Object.fromEntries(
+  Object.entries(TRACKING_CAMEL_TO_KEBAB).map(([camel, kebab]) => [kebab, camel])
+);
+
+// --- Key Conversion Helpers ---
+
+function toKebabKeys(obj: unknown): unknown {
+  if (obj === null || obj === undefined) return obj;
+  if (Array.isArray(obj)) return obj.map(toKebabKeys);
+  if (typeof obj !== 'object') return obj;
+
+  const result: Record<string, unknown> = {};
+  for (const [key, value] of Object.entries(obj as Record<string, unknown>)) {
+    const kebabKey = TRACKING_CAMEL_TO_KEBAB[key] ?? key;
+    result[kebabKey] = toKebabKeys(value);
+  }
+  return result;
+}
+
+function toCamelKeys(obj: unknown): unknown {
+  if (obj === null || obj === undefined) return obj;
+  if (Array.isArray(obj)) return obj.map(toCamelKeys);
+  if (typeof obj !== 'object') return obj;
+
+  const result: Record<string, unknown> = {};
+  for (const [key, value] of Object.entries(obj as Record<string, unknown>)) {
+    const camelKey = TRACKING_KEBAB_TO_CAMEL[key] ?? key;
+    result[camelKey] = toCamelKeys(value);
+  }
+  return result;
+}
+
+// --- Serialization ---
+
+function serializeTrackingEntry(entry: TrackingEntry): string {
+  const kebabObj = toKebabKeys(entry);
+  return stringify(kebabObj, { nullStr: 'null', lineWidth: 0 });
+}
+
+function deserializeTrackingEntry(yamlStr: string): TrackingEntry {
+  const parsed = parse(yamlStr);
+  return toCamelKeys(parsed) as TrackingEntry;
+}
+
+// --- Directory Helpers ---
+
+function getTrackingDir(basePath: string = process.cwd()): string {
+  return join(basePath, 'kb', 'tracking');
+}
+
+function getTrackingFilePath(id: string, basePath: string = process.cwd()): string {
+  return join(getTrackingDir(basePath), `${id}.yaml`);
+}
+
+// --- Read All Entries ---
+
+async function readAllEntries(basePath: string = process.cwd()): Promise<TrackingEntry[]> {
+  const dir = getTrackingDir(basePath);
+  let files: string[];
+  try {
+    files = await readdir(dir);
+  } catch (err: unknown) {
+    if (err instanceof Error && 'code' in err && (err as NodeJS.ErrnoException).code === 'ENOENT') {
+      return [];
+    }
+    throw err;
+  }
+
+  const yamlFiles = files.filter((f) => f.endsWith('.yaml'));
+  const entries: TrackingEntry[] = [];
+
+  for (const file of yamlFiles) {
+    const content = await readFile(join(dir, file), 'utf-8');
+    entries.push(deserializeTrackingEntry(content));
+  }
+
+  return entries;
+}
+
+// --- Best Practice Detection ---
+
+/**
+ * Marks posts as best practice when their engagement rate exceeds
+ * the average engagement rate of all posts in the entry.
+ */
+function markBestPractices(entry: TrackingEntry): TrackingEntry {
+  if (!entry.posts || entry.posts.length === 0) return entry;
+
+  const avgEngagement =
+    entry.posts.reduce((sum, p) => sum + p.engagementRate, 0) / entry.posts.length;
+
+  const markedPosts = entry.posts.map((post) => ({
+    ...post,
+    isBestPractice: post.engagementRate > avgEngagement,
+  }));
+
+  return { ...entry, posts: markedPosts };
+}
+
+// --- Public API ---
+
+/**
+ * Adds a tracking entry to kb/tracking/ as a YAML file.
+ * Automatically marks posts as best practice when their engagement rate
+ * exceeds the average of all posts in the entry.
+ */
+export async function addTrackingEntry(
+  entry: TrackingEntry,
+  basePath: string = process.cwd()
+): Promise<void> {
+  const dir = getTrackingDir(basePath);
+  await mkdir(dir, { recursive: true });
+
+  const markedEntry = markBestPractices(entry);
+  const yaml = serializeTrackingEntry(markedEntry);
+  const filePath = getTrackingFilePath(entry.id, basePath);
+  await writeFile(filePath, yaml, 'utf-8');
+}
+
+/**
+ * Generates a weekly report for the given week start date.
+ * Aggregates metrics and posts, identifies the top post,
+ * and calculates week-over-week changes.
+ */
+export async function getWeeklyReport(
+  weekOf: string,
+  basePath: string = process.cwd()
+): Promise<WeeklyReport> {
+  const entries = await readAllEntries(basePath);
+
+  const weekStart = new Date(weekOf);
+  const weekEnd = new Date(weekStart);
+  weekEnd.setDate(weekEnd.getDate() + 7);
+
+  // Find entries within the target week
+  const weekEntries = entries.filter((e) => {
+    const d = new Date(e.date);
+    return d >= weekStart && d < weekEnd;
+  });
+
+  // Find entries from the previous week for comparison
+  const prevWeekStart = new Date(weekStart);
+  prevWeekStart.setDate(prevWeekStart.getDate() - 7);
+  const prevWeekEntries = entries.filter((e) => {
+    const d = new Date(e.date);
+    return d >= prevWeekStart && d < weekStart;
+  });
+
+  // Aggregate current week metrics
+  const metrics = aggregateMetrics(weekEntries);
+  const posts = weekEntries.flatMap((e) => e.posts ?? []);
+  const topPost = posts.length > 0
+    ? posts.reduce((best, p) => (p.engagementRate > best.engagementRate ? p : best))
+    : undefined;
+
+  // Aggregate previous week metrics for comparison
+  const prevMetrics = aggregateMetrics(prevWeekEntries);
+
+  const weekOverWeek = {
+    profileViewsChange: calculateChange(prevMetrics.profileViews, metrics.profileViews),
+    impressionsChange: calculateChange(prevMetrics.postImpressions ?? 0, metrics.postImpressions ?? 0),
+    engagementRateChange: calculateChange(prevMetrics.engagementRate ?? 0, metrics.engagementRate ?? 0),
+  };
+
+  return { weekOf, metrics, posts, topPost, weekOverWeek };
+}
+
+/**
+ * Generates a monthly trend analysis for the given month.
+ * Calculates averages, identifies best practices, computes growth,
+ * and derives content optimization recommendations.
+ */
+export async function getMonthlyTrend(
+  month: string,
+  basePath: string = process.cwd()
+): Promise<MonthlyTrend> {
+  const entries = await readAllEntries(basePath);
+
+  // Filter entries for the target month (format: "2026-07")
+  const monthEntries = entries.filter((e) => e.date.startsWith(month));
+
+  // Filter entries for the previous month
+  const prevMonth = getPreviousMonth(month);
+  const prevMonthEntries = entries.filter((e) => e.date.startsWith(prevMonth));
+
+  // Calculate averages for the month
+  const averageMetrics = calculateAverageMetrics(monthEntries);
+  const prevAverageMetrics = calculateAverageMetrics(prevMonthEntries);
+
+  // Collect all posts and identify best practices
+  const allPosts = monthEntries.flatMap((e) => e.posts ?? []);
+  const totalPosts = allPosts.length;
+  const bestPractices = allPosts.filter((p) => p.isBestPractice === true);
+
+  // Calculate growth percentages
+  const growth = {
+    profileViews: calculateChange(prevAverageMetrics.profileViews, averageMetrics.profileViews),
+    impressions: calculateChange(prevAverageMetrics.postImpressions, averageMetrics.postImpressions),
+    engagement: calculateChange(prevAverageMetrics.engagementRate, averageMetrics.engagementRate),
+  };
+
+  // Derive recommendations
+  const recommendations = deriveRecommendations(allPosts, averageMetrics, growth);
+
+  return {
+    month,
+    averageMetrics,
+    totalPosts,
+    bestPractices,
+    growth,
+    recommendations,
+  };
+}
+
+// --- Aggregation Helpers ---
+
+function aggregateMetrics(entries: TrackingEntry[]): TrackingEntry['metrics'] {
+  if (entries.length === 0) {
+    return {
+      profileViews: 0,
+      searchAppearances: 0,
+      connectionRequests: 0,
+      postImpressions: 0,
+      engagementRate: 0,
+      comments: 0,
+      reposts: 0,
+    };
+  }
+
+  return {
+    profileViews: sum(entries, (e) => e.metrics.profileViews),
+    searchAppearances: sum(entries, (e) => e.metrics.searchAppearances),
+    connectionRequests: sum(entries, (e) => e.metrics.connectionRequests),
+    postImpressions: sum(entries, (e) => e.metrics.postImpressions ?? 0),
+    engagementRate: avg(entries, (e) => e.metrics.engagementRate ?? 0),
+    comments: sum(entries, (e) => e.metrics.comments ?? 0),
+    reposts: sum(entries, (e) => e.metrics.reposts ?? 0),
+  };
+}
+
+function calculateAverageMetrics(entries: TrackingEntry[]): MonthlyTrend['averageMetrics'] {
+  if (entries.length === 0) {
+    return { profileViews: 0, searchAppearances: 0, postImpressions: 0, engagementRate: 0 };
+  }
+
+  return {
+    profileViews: avg(entries, (e) => e.metrics.profileViews),
+    searchAppearances: avg(entries, (e) => e.metrics.searchAppearances),
+    postImpressions: avg(entries, (e) => e.metrics.postImpressions ?? 0),
+    engagementRate: avg(entries, (e) => e.metrics.engagementRate ?? 0),
+  };
+}
+
+// --- Trend & Change Calculation ---
+
+function calculateChange(previous: number, current: number): number {
+  if (previous === 0) return current > 0 ? 100 : 0;
+  return Math.round(((current - previous) / previous) * 100);
+}
+
+function getPreviousMonth(month: string): string {
+  const [year, m] = month.split('-').map(Number);
+  if (m === 1) return `${year - 1}-12`;
+  return `${year}-${String(m - 1).padStart(2, '0')}`;
+}
+
+// --- Recommendations Engine ---
+
+function deriveRecommendations(
+  posts: PostMetric[],
+  averageMetrics: MonthlyTrend['averageMetrics'],
+  growth: MonthlyTrend['growth']
+): string[] {
+  const recommendations: string[] = [];
+
+  if (posts.length === 0) {
+    recommendations.push('Noch keine Posts im Zeitraum — regelmäßiges Posting aufbauen (Ziel: 2x/Woche).');
+    return recommendations;
+  }
+
+  // Analyze format performance
+  const formatPerformance = analyzeFormatPerformance(posts);
+  const bestFormat = formatPerformance.sort((a, b) => b.avgEngagement - a.avgEngagement)[0];
+  if (bestFormat) {
+    recommendations.push(
+      `Format "${bestFormat.format}" zeigt die höchste Engagement-Rate (${bestFormat.avgEngagement.toFixed(1)}%) — Anteil erhöhen.`
+    );
+  }
+
+  // Engagement trend
+  if (growth.engagement < 0) {
+    recommendations.push(
+      'Engagement-Rate rückläufig — mehr interaktive Formate (Fragen, Umfragen) einsetzen.'
+    );
+  } else if (growth.engagement > 20) {
+    recommendations.push(
+      'Starkes Engagement-Wachstum — aktuelle Content-Strategie beibehalten und ausbauen.'
+    );
+  }
+
+  // Profile visibility
+  if (growth.profileViews < 0) {
+    recommendations.push(
+      'Profilaufrufe rückläufig — Posting-Frequenz und Kommentar-Aktivität erhöhen.'
+    );
+  }
+
+  // Best practice analysis
+  const bestPractices = posts.filter((p) => p.isBestPractice);
+  if (bestPractices.length > 0) {
+    const bpFormats = [...new Set(bestPractices.map((p) => p.format))];
+    recommendations.push(
+      `Best-Practice-Posts nutzen bevorzugt: ${bpFormats.join(', ')} — diese Formate priorisieren.`
+    );
+  }
+
+  // Low engagement posts
+  const avgEngagement = posts.reduce((s, p) => s + p.engagementRate, 0) / posts.length;
+  const lowPerformers = posts.filter((p) => p.engagementRate < avgEngagement * 0.5);
+  if (lowPerformers.length > 0) {
+    recommendations.push(
+      `${lowPerformers.length} Post(s) mit unterdurchschnittlicher Performance — Themen und Timing überprüfen.`
+    );
+  }
+
+  return recommendations;
+}
+
+interface FormatPerformance {
+  format: string;
+  count: number;
+  avgEngagement: number;
+}
+
+function analyzeFormatPerformance(posts: PostMetric[]): FormatPerformance[] {
+  const byFormat = new Map<string, PostMetric[]>();
+  for (const post of posts) {
+    const existing = byFormat.get(post.format) ?? [];
+    existing.push(post);
+    byFormat.set(post.format, existing);
+  }
+
+  return Array.from(byFormat.entries()).map(([format, formatPosts]) => ({
+    format,
+    count: formatPosts.length,
+    avgEngagement: formatPosts.reduce((s, p) => s + p.engagementRate, 0) / formatPosts.length,
+  }));
+}
+
+// --- Math Helpers ---
+
+function sum<T>(items: T[], getter: (item: T) => number): number {
+  return items.reduce((s, item) => s + getter(item), 0);
+}
+
+function avg<T>(items: T[], getter: (item: T) => number): number {
+  if (items.length === 0) return 0;
+  return sum(items, getter) / items.length;
+}

privat/CV/src/linkedin/tracking-output.test.ts

@@ -0,0 +1,247 @@
+/**
+ * Tests for LinkedIn Tracking Report Output
+ *
+ * Validates that tracking data is correctly formatted as Markdown
+ * and written to the expected output path.
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { mkdtemp, mkdir, writeFile, readFile, rm } from 'node:fs/promises';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { stringify } from 'yaml';
+import { generateTrackingReport } from './tracking-output';
+
+describe('tracking-output', () => {
+  let tempDir: string;
+
+  beforeEach(async () => {
+    tempDir = await mkdtemp(join(tmpdir(), 'tracking-output-'));
+    await mkdir(join(tempDir, 'kb', 'tracking'), { recursive: true });
+    await mkdir(join(tempDir, 'output', 'linkedin'), { recursive: true });
+  });
+
+  afterEach(async () => {
+    await rm(tempDir, { recursive: true, force: true });
+  });
+
+  function writeTrackingEntry(id: string, data: Record<string, unknown>) {
+    const filePath = join(tempDir, 'kb', 'tracking', `${id}.yaml`);
+    return writeFile(filePath, stringify(data), 'utf-8');
+  }
+
+  describe('generateTrackingReport', () => {
+    it('generates a weekly report with metrics and posts', async () => {
+      await writeTrackingEntry('linkedin-2026-w28', {
+        id: 'linkedin-2026-w28',
+        type: 'linkedin-tracking',
+        date: '2026-07-13',
+        metrics: {
+          'profile-views': 142,
+          'search-appearances': 38,
+          'connection-requests': 12,
+          'post-impressions': 4500,
+          'engagement-rate': 4.2,
+          comments: 23,
+          reposts: 8,
+        },
+        posts: [
+          {
+            title: 'KI in der Bahn',
+            date: '2026-07-10',
+            format: 'text',
+            impressions: 2100,
+            'engagement-rate': 5.1,
+            comments: 14,
+            reposts: 5,
+            'is-best-practice': true,
+          },
+          {
+            title: 'Carousel: 5 Fehler',
+            date: '2026-07-12',
+            format: 'carousel',
+            impressions: 2400,
+            'engagement-rate': 3.8,
+            comments: 9,
+            reposts: 3,
+            'is-best-practice': false,
+          },
+        ],
+      });
+
+      const result = await generateTrackingReport({
+        weekOf: '2026-07-13',
+        basePath: tempDir,
+        outputDir: join(tempDir, 'output', 'linkedin'),
+      });
+
+      expect(result.hasWeeklyData).toBe(true);
+      expect(result.markdown).toContain('# LinkedIn Tracking Report');
+      expect(result.markdown).toContain('Generated:');
+      expect(result.markdown).toContain('## Wöchentlicher Report');
+      expect(result.markdown).toContain('Woche ab: 2026-07-13');
+      expect(result.markdown).toContain('142');
+      expect(result.markdown).toContain('4500');
+      expect(result.markdown).toContain('KI in der Bahn');
+      expect(result.markdown).toContain('Carousel: 5 Fehler');
+      expect(result.markdown).toContain('### Top-Beitrag');
+    });
+
+    it('generates a monthly trend report with recommendations', async () => {
+      await writeTrackingEntry('linkedin-2026-w28', {
+        id: 'linkedin-2026-w28',
+        type: 'linkedin-tracking',
+        date: '2026-07-13',
+        metrics: {
+          'profile-views': 142,
+          'search-appearances': 38,
+          'connection-requests': 12,
+          'post-impressions': 4500,
+          'engagement-rate': 4.2,
+          comments: 23,
+          reposts: 8,
+        },
+        posts: [
+          {
+            title: 'Top Post',
+            date: '2026-07-10',
+            format: 'text',
+            impressions: 2100,
+            'engagement-rate': 5.1,
+            comments: 14,
+            reposts: 5,
+            'is-best-practice': true,
+          },
+        ],
+      });
+
+      const result = await generateTrackingReport({
+        month: '2026-07',
+        basePath: tempDir,
+        outputDir: join(tempDir, 'output', 'linkedin'),
+      });
+
+      expect(result.hasMonthlyData).toBe(true);
+      expect(result.markdown).toContain('## Monatliche Trendanalyse');
+      expect(result.markdown).toContain('Monat: 2026-07');
+      expect(result.markdown).toContain('### Durchschnittliche Metriken');
+      expect(result.markdown).toContain('### Empfehlungen');
+    });
+
+    it('generates both weekly and monthly sections when both options provided', async () => {
+      await writeTrackingEntry('linkedin-2026-w28', {
+        id: 'linkedin-2026-w28',
+        type: 'linkedin-tracking',
+        date: '2026-07-13',
+        metrics: {
+          'profile-views': 100,
+          'search-appearances': 20,
+          'connection-requests': 5,
+          'post-impressions': 2000,
+          'engagement-rate': 3.0,
+          comments: 10,
+          reposts: 4,
+        },
+        posts: [],
+      });
+
+      const result = await generateTrackingReport({
+        weekOf: '2026-07-13',
+        month: '2026-07',
+        basePath: tempDir,
+        outputDir: join(tempDir, 'output', 'linkedin'),
+      });
+
+      expect(result.hasWeeklyData).toBe(true);
+      expect(result.hasMonthlyData).toBe(true);
+      expect(result.markdown).toContain('## Wöchentlicher Report');
+      expect(result.markdown).toContain('## Monatliche Trendanalyse');
+    });
+
+    it('writes the report to the correct file path', async () => {
+      const result = await generateTrackingReport({
+        weekOf: '2026-07-13',
+        basePath: tempDir,
+        outputDir: join(tempDir, 'output', 'linkedin'),
+      });
+
+      const expectedPath = join(tempDir, 'output', 'linkedin', 'tracking-report.md');
+      expect(result.filePath).toBe(expectedPath);
+
+      const content = await readFile(expectedPath, 'utf-8');
+      expect(content).toBe(result.markdown);
+    });
+
+    it('handles empty tracking data gracefully', async () => {
+      const result = await generateTrackingReport({
+        weekOf: '2026-07-13',
+        month: '2026-07',
+        basePath: tempDir,
+        outputDir: join(tempDir, 'output', 'linkedin'),
+      });
+
+      expect(result.markdown).toContain('# LinkedIn Tracking Report');
+      // Weekly report with zero metrics
+      expect(result.markdown).toContain('## Wöchentlicher Report');
+      // Monthly with no posts
+      expect(result.markdown).toContain('Beiträge gesamt: 0');
+    });
+
+    it('includes week-over-week changes in weekly report', async () => {
+      // Previous week
+      await writeTrackingEntry('linkedin-2026-w27', {
+        id: 'linkedin-2026-w27',
+        type: 'linkedin-tracking',
+        date: '2026-07-06',
+        metrics: {
+          'profile-views': 100,
+          'search-appearances': 30,
+          'connection-requests': 8,
+          'post-impressions': 3000,
+          'engagement-rate': 3.0,
+          comments: 15,
+          reposts: 5,
+        },
+        posts: [],
+      });
+
+      // Current week
+      await writeTrackingEntry('linkedin-2026-w28', {
+        id: 'linkedin-2026-w28',
+        type: 'linkedin-tracking',
+        date: '2026-07-13',
+        metrics: {
+          'profile-views': 150,
+          'search-appearances': 40,
+          'connection-requests': 12,
+          'post-impressions': 4500,
+          'engagement-rate': 4.5,
+          comments: 25,
+          reposts: 10,
+        },
+        posts: [],
+      });
+
+      const result = await generateTrackingReport({
+        weekOf: '2026-07-13',
+        basePath: tempDir,
+        outputDir: join(tempDir, 'output', 'linkedin'),
+      });
+
+      // Should show positive changes
+      expect(result.markdown).toContain('+50%'); // profile views: 100 -> 150
+      expect(result.markdown).toContain('+50%'); // impressions: 3000 -> 4500
+    });
+
+    it('formats the change indicators correctly', async () => {
+      const result = await generateTrackingReport({
+        weekOf: '2026-07-13',
+        basePath: tempDir,
+        outputDir: join(tempDir, 'output', 'linkedin'),
+      });
+
+      // With no previous data, changes should be 0
+      expect(result.markdown).toContain('±0%');
+    });
+  });
+});

privat/CV/src/linkedin/tracking-output.ts

@@ -0,0 +1,227 @@
+/**
+ * LinkedIn Tracking Report Output
+ *
+ * Generates structured Markdown reports from tracking data.
+ * Combines weekly and monthly reports into output/linkedin/tracking-report.md.
+ *
+ * Requirements: 8.1–8.7
+ */
+
+import { writeFile, mkdir } from 'node:fs/promises';
+import { join } from 'node:path';
+import { getWeeklyReport, getMonthlyTrend } from './tracking-manager';
+import type { WeeklyReport, MonthlyTrend, PostMetric } from './types';
+
+// --- Public API ---
+
+export interface TrackingReportOptions {
+  /** ISO date string for the week start (e.g., "2026-07-07") */
+  weekOf?: string;
+  /** Month identifier (e.g., "2026-07") */
+  month?: string;
+  /** Base path for KB data (defaults to process.cwd()) */
+  basePath?: string;
+  /** Output directory (defaults to output/linkedin) */
+  outputDir?: string;
+}
+
+export interface TrackingReportResult {
+  /** The generated Markdown content */
+  markdown: string;
+  /** Path where the report was written */
+  filePath: string;
+  /** Whether weekly data was included */
+  hasWeeklyData: boolean;
+  /** Whether monthly data was included */
+  hasMonthlyData: boolean;
+}
+
+/**
+ * Generates a tracking report and writes it to output/linkedin/tracking-report.md.
+ * Includes weekly and/or monthly sections depending on provided options.
+ */
+export async function generateTrackingReport(
+  options: TrackingReportOptions = {}
+): Promise<TrackingReportResult> {
+  const basePath = options.basePath ?? process.cwd();
+  const outputDir = options.outputDir ?? join(basePath, 'output', 'linkedin');
+
+  let weeklyReport: WeeklyReport | undefined;
+  let monthlyTrend: MonthlyTrend | undefined;
+
+  if (options.weekOf) {
+    weeklyReport = await getWeeklyReport(options.weekOf, basePath);
+  }
+
+  if (options.month) {
+    monthlyTrend = await getMonthlyTrend(options.month, basePath);
+  }
+
+  // If neither specified, default to current week and month
+  if (!options.weekOf && !options.month) {
+    const now = new Date();
+    const weekStart = getWeekStart(now);
+    const month = `${now.getFullYear()}-${String(now.getMonth() + 1).padStart(2, '0')}`;
+
+    weeklyReport = await getWeeklyReport(weekStart, basePath);
+    monthlyTrend = await getMonthlyTrend(month, basePath);
+  }
+
+  const markdown = formatTrackingReport(weeklyReport, monthlyTrend);
+
+  await mkdir(outputDir, { recursive: true });
+  const filePath = join(outputDir, 'tracking-report.md');
+  await writeFile(filePath, markdown, 'utf-8');
+
+  return {
+    markdown,
+    filePath,
+    hasWeeklyData: weeklyReport !== undefined,
+    hasMonthlyData: monthlyTrend !== undefined,
+  };
+}
+
+// --- Markdown Formatting ---
+
+function formatTrackingReport(
+  weekly?: WeeklyReport,
+  monthly?: MonthlyTrend
+): string {
+  const lines: string[] = [];
+  const generatedDate = new Date().toISOString().split('T')[0];
+
+  lines.push('# LinkedIn Tracking Report');
+  lines.push(`Generated: ${generatedDate}`);
+  lines.push('');
+
+  if (weekly) {
+    lines.push(...formatWeeklySection(weekly));
+    lines.push('');
+  }
+
+  if (monthly) {
+    lines.push(...formatMonthlySection(monthly));
+    lines.push('');
+  }
+
+  if (!weekly && !monthly) {
+    lines.push('> Keine Tracking-Daten vorhanden. Bitte zuerst Metriken über den Tracking Manager erfassen.');
+    lines.push('');
+  }
+
+  return lines.join('\n');
+}
+
+function formatWeeklySection(report: WeeklyReport): string[] {
+  const lines: string[] = [];
+
+  lines.push('## Wöchentlicher Report');
+  lines.push(`Woche ab: ${report.weekOf}`);
+  lines.push('');
+
+  // Metrics table
+  lines.push('### Profil-Metriken');
+  lines.push('');
+  lines.push('| Metrik | Wert | Veränderung |');
+  lines.push('|--------|------|-------------|');
+  lines.push(`| Profilaufrufe | ${report.metrics.profileViews} | ${formatChange(report.weekOverWeek.profileViewsChange)} |`);
+  lines.push(`| Suchergebnisse | ${report.metrics.searchAppearances} | — |`);
+  lines.push(`| Vernetzungsanfragen | ${report.metrics.connectionRequests} | — |`);
+  lines.push(`| Impressionen | ${report.metrics.postImpressions ?? 0} | ${formatChange(report.weekOverWeek.impressionsChange)} |`);
+  lines.push(`| Engagement-Rate | ${(report.metrics.engagementRate ?? 0).toFixed(1)}% | ${formatChange(report.weekOverWeek.engagementRateChange)} |`);
+  lines.push(`| Kommentare | ${report.metrics.comments ?? 0} | — |`);
+  lines.push(`| Reposts | ${report.metrics.reposts ?? 0} | — |`);
+  lines.push('');
+
+  // Posts
+  if (report.posts.length > 0) {
+    lines.push('### Beiträge dieser Woche');
+    lines.push('');
+    lines.push('| Titel | Format | Impressionen | Engagement | Best Practice |');
+    lines.push('|-------|--------|--------------|------------|---------------|');
+    for (const post of report.posts) {
+      lines.push(
+        `| ${post.title} | ${post.format} | ${post.impressions} | ${post.engagementRate.toFixed(1)}% | ${post.isBestPractice ? '✅' : '—'} |`
+      );
+    }
+    lines.push('');
+  }
+
+  // Top post
+  if (report.topPost) {
+    lines.push('### Top-Beitrag');
+    lines.push('');
+    lines.push(`**${report.topPost.title}**`);
+    lines.push(`- Format: ${report.topPost.format}`);
+    lines.push(`- Impressionen: ${report.topPost.impressions}`);
+    lines.push(`- Engagement-Rate: ${report.topPost.engagementRate.toFixed(1)}%`);
+    lines.push(`- Kommentare: ${report.topPost.comments} | Reposts: ${report.topPost.reposts}`);
+    lines.push('');
+  }
+
+  return lines;
+}
+
+function formatMonthlySection(trend: MonthlyTrend): string[] {
+  const lines: string[] = [];
+
+  lines.push('## Monatliche Trendanalyse');
+  lines.push(`Monat: ${trend.month}`);
+  lines.push('');
+
+  // Average metrics
+  lines.push('### Durchschnittliche Metriken');
+  lines.push('');
+  lines.push('| Metrik | Durchschnitt | Wachstum |');
+  lines.push('|--------|--------------|----------|');
+  lines.push(`| Profilaufrufe | ${trend.averageMetrics.profileViews.toFixed(0)} | ${formatChange(trend.growth.profileViews)} |`);
+  lines.push(`| Suchergebnisse | ${trend.averageMetrics.searchAppearances.toFixed(0)} | — |`);
+  lines.push(`| Impressionen | ${trend.averageMetrics.postImpressions.toFixed(0)} | ${formatChange(trend.growth.impressions)} |`);
+  lines.push(`| Engagement-Rate | ${trend.averageMetrics.engagementRate.toFixed(1)}% | ${formatChange(trend.growth.engagement)} |`);
+  lines.push('');
+
+  // Summary
+  lines.push('### Zusammenfassung');
+  lines.push('');
+  lines.push(`- Beiträge gesamt: ${trend.totalPosts}`);
+  lines.push(`- Best Practices: ${trend.bestPractices.length}`);
+  lines.push('');
+
+  // Best practices
+  if (trend.bestPractices.length > 0) {
+    lines.push('### Best-Practice-Beiträge');
+    lines.push('');
+    for (const post of trend.bestPractices) {
+      lines.push(`- **${post.title}** (${post.format}, ${post.date}) — ${post.engagementRate.toFixed(1)}% Engagement`);
+    }
+    lines.push('');
+  }
+
+  // Recommendations
+  if (trend.recommendations.length > 0) {
+    lines.push('### Empfehlungen');
+    lines.push('');
+    for (const rec of trend.recommendations) {
+      lines.push(`- ${rec}`);
+    }
+    lines.push('');
+  }
+
+  return lines;
+}
+
+// --- Helpers ---
+
+function formatChange(change: number): string {
+  if (change === 0) return '±0%';
+  if (change > 0) return `+${change}%`;
+  return `${change}%`;
+}
+
+function getWeekStart(date: Date): string {
+  const d = new Date(date);
+  const day = d.getDay();
+  const diff = d.getDate() - day + (day === 0 ? -6 : 1); // Monday as start
+  d.setDate(diff);
+  return d.toISOString().split('T')[0];
+}

privat/CV/src/linkedin/types.ts

@@ -0,0 +1,254 @@
+/**
+ * LinkedIn Profile Module — Type Definitions
+ *
+ * TypeScript interfaces for all LinkedIn profile generation, content strategy,
+ * and tracking modules. Properties use camelCase consistent with project conventions.
+ */
+
+import type { ConstraintValidation } from './constraints';
+
+// --- Headline Generator ---
+
+/** Options for generating LinkedIn headline variants. */
+export interface HeadlineOptions {
+  /** Reference to a Person entity ID */
+  personId: string;
+  /** Emphasis direction for the headline */
+  emphasis?: 'dual-role' | 'ai-expert' | 'leadership';
+  /** Number of headline variants to generate (default: 3) */
+  variants?: number;
+}
+
+/** Result of headline generation including all variants and validation. */
+export interface HeadlineResult {
+  variants: HeadlineVariant[];
+  validation: ConstraintValidation;
+}
+
+/** A single headline variant with metadata. */
+export interface HeadlineVariant {
+  /** The headline text */
+  text: string;
+  /** Character count of the headline */
+  charCount: number;
+  /** Keywords contained in the headline */
+  keywords: string[];
+  /** Roles mentioned in the headline */
+  roles: string[];
+}
+
+// --- About Section Generator ---
+
+/** Options for generating the LinkedIn About section. */
+export interface AboutOptions {
+  /** Reference to a Person entity ID */
+  personId: string;
+  /** Tone of the About section */
+  tone?: 'nahbar' | 'fachlich' | 'inspirierend';
+  /** Whether to include stats/numbers (default: true) */
+  includeStats?: boolean;
+}
+
+/** Result of About section generation. */
+export interface AboutResult {
+  /** Complete About section text */
+  fullText: string;
+  /** Character count of the full text */
+  charCount: number;
+  /** First 2 lines visible before "mehr anzeigen" */
+  hookPreview: string;
+  /** Structured sections of the About text */
+  sections: {
+    hook: string;
+    mission: string;
+    expertise: string;
+    cta: string;
+  };
+  validation: ConstraintValidation;
+}
+
+// --- Experience Generator ---
+
+/** Options for generating LinkedIn experience descriptions. */
+export interface ExperienceOptions {
+  /** Reference to a Person entity ID */
+  personId: string;
+  /** Specific experience IDs to generate, or all if omitted */
+  experienceIds?: string[];
+  /** SEO keywords to include in descriptions */
+  keywords?: string[];
+}
+
+/** Result for a single experience description. */
+export interface ExperienceResult {
+  /** Reference to the Experience entity ID */
+  experienceId: string;
+  /** Job title */
+  title: string;
+  /** Organization name */
+  organization: string;
+  /** Generated description text */
+  description: string;
+  /** Keywords included in the description */
+  keywords: string[];
+  /** Measurable achievements extracted/generated */
+  achievements: string[];
+  validation: ConstraintValidation;
+}
+
+// --- Content Strategy Generator ---
+
+/** Options for generating a content strategy. */
+export interface ContentStrategyOptions {
+  /** Reference to a Person entity ID */
+  personId: string;
+  /** Target quarter (e.g., "2026-Q3") */
+  quarter: string;
+  /** Existing content formats to integrate (e.g., podcast, column) */
+  existingFormats?: string[];
+}
+
+/** Complete content strategy for a quarter. */
+export interface ContentStrategy {
+  /** Recommended posting frequency (e.g., "2 Beiträge pro Woche") */
+  postingFrequency: string;
+  /** Theme clusters with weighting */
+  themeCluster: ThemeCluster[];
+  /** Weekly posting plan */
+  weeklyPlan: WeeklySlot[];
+  /** Engagement routine definition */
+  engagementRoutine: EngagementRoutine;
+  /** Format distribution */
+  formatMix: FormatMix;
+}
+
+/** A theme cluster with topic and weight. */
+export interface ThemeCluster {
+  /** Cluster name (e.g., "Innovation & Technologie") */
+  name: string;
+  /** Weight as percentage (e.g., 40) */
+  weight: number;
+  /** Example topics within this cluster */
+  topics: string[];
+}
+
+/** A weekly posting slot. */
+export interface WeeklySlot {
+  /** Day of the week (e.g., "Dienstag") */
+  day: string;
+  /** Time of day for posting */
+  time: string;
+  /** Preferred format for this slot */
+  format: string;
+  /** Theme cluster this slot belongs to */
+  themeCluster: string;
+}
+
+/** Engagement routine definition. */
+export interface EngagementRoutine {
+  /** Minimum comments per week on other posts */
+  commentsPerWeek: number;
+  /** Target accounts to engage with */
+  targetAccounts: string[];
+  /** Daily time investment for engagement */
+  dailyTimeMinutes: number;
+}
+
+/** Format distribution for content mix. */
+export interface FormatMix {
+  /** Percentage of text posts */
+  text: number;
+  /** Percentage of carousel posts */
+  carousel: number;
+  /** Percentage of video posts */
+  video: number;
+  /** Percentage of newsletter posts */
+  newsletter: number;
+}
+
+// --- Tracking Manager ---
+
+/** A single tracking entry for LinkedIn metrics. */
+export interface TrackingEntry {
+  /** Unique identifier (e.g., "linkedin-2026-w28") */
+  id: string;
+  /** Entity type discriminator */
+  type: 'linkedin-tracking';
+  /** ISO date of the tracking entry */
+  date: string;
+  /** Aggregated metrics for the period */
+  metrics: {
+    profileViews: number;
+    searchAppearances: number;
+    connectionRequests: number;
+    postImpressions?: number;
+    engagementRate?: number;
+    comments?: number;
+    reposts?: number;
+  };
+  /** Individual post metrics for the period */
+  posts?: PostMetric[];
+}
+
+/** Metrics for a single LinkedIn post. */
+export interface PostMetric {
+  /** Post title or first line */
+  title: string;
+  /** ISO date of publication */
+  date: string;
+  /** Content format */
+  format: 'text' | 'carousel' | 'video' | 'newsletter';
+  /** Total impressions */
+  impressions: number;
+  /** Engagement rate as percentage */
+  engagementRate: number;
+  /** Number of comments */
+  comments: number;
+  /** Number of reposts/shares */
+  reposts: number;
+  /** Whether this post is marked as best practice */
+  isBestPractice?: boolean;
+}
+
+/** Weekly performance report. */
+export interface WeeklyReport {
+  /** ISO date of the week start */
+  weekOf: string;
+  /** Aggregated metrics for the week */
+  metrics: TrackingEntry['metrics'];
+  /** Posts published during the week */
+  posts: PostMetric[];
+  /** Top performing post of the week */
+  topPost?: PostMetric;
+  /** Comparison to previous week */
+  weekOverWeek: {
+    profileViewsChange: number;
+    impressionsChange: number;
+    engagementRateChange: number;
+  };
+}
+
+/** Monthly trend analysis. */
+export interface MonthlyTrend {
+  /** Month identifier (e.g., "2026-07") */
+  month: string;
+  /** Average metrics across the month */
+  averageMetrics: {
+    profileViews: number;
+    searchAppearances: number;
+    postImpressions: number;
+    engagementRate: number;
+  };
+  /** Total posts published */
+  totalPosts: number;
+  /** Best performing posts of the month */
+  bestPractices: PostMetric[];
+  /** Growth compared to previous month as percentages */
+  growth: {
+    profileViews: number;
+    impressions: number;
+    engagement: number;
+  };
+  /** Data-driven recommendations for content optimization */
+  recommendations: string[];
+}

privat/CV/src/review/completeness-score.ts

@@ -0,0 +1,159 @@
+/**
+ * Completeness Score — calculates how complete an entity's profile is.
+ *
+ * Pure function, no I/O. Uses the same field definitions as gap-detection.ts.
+ */
+
+import type { Entity, EntityType } from '../schemas/types';
+
+// --- Types ---
+
+export interface CompletenessResult {
+  /** Completeness ratio from 0.0 to 1.0 */
+  score: number;
+  /** Number of filled attributes */
+  filledCount: number;
+  /** Total number of defined attributes */
+  totalCount: number;
+  /** List of missing field names */
+  missingFields: string[];
+}
+
+// --- Field Definitions per Entity Type ---
+
+interface FieldDef {
+  field: string;
+  description: string;
+}
+
+const PERSON_FIELDS: FieldDef[] = [
+  { field: 'name.first', description: 'First name' },
+  { field: 'name.last', description: 'Last name' },
+  { field: 'name.display', description: 'Display name' },
+  { field: 'contact', description: 'Contact information' },
+  { field: 'summary', description: 'Professional summary' },
+  { field: 'languages', description: 'Languages spoken' },
+  { field: 'education', description: 'Education history' },
+  { field: 'skills', description: 'Skills references' },
+  { field: 'experiences', description: 'Experience references' },
+  { field: 'certifications', description: 'Certification references' },
+];
+
+const EXPERIENCE_FIELDS: FieldDef[] = [
+  { field: 'title', description: 'Job title' },
+  { field: 'organization', description: 'Organization reference' },
+  { field: 'start', description: 'Start date' },
+  { field: 'description', description: 'Role description' },
+  { field: 'achievements', description: 'Achievements list' },
+  { field: 'skillsUsed', description: 'Skills used in this role' },
+];
+
+const SKILL_FIELDS: FieldDef[] = [
+  { field: 'name', description: 'Skill name' },
+  { field: 'category', description: 'Skill category' },
+  { field: 'level', description: 'Proficiency level' },
+  { field: 'years', description: 'Years of experience' },
+  { field: 'context', description: 'Context of skill usage' },
+];
+
+const ORGANIZATION_FIELDS: FieldDef[] = [
+  { field: 'name', description: 'Organization name' },
+  { field: 'industry', description: 'Industry sector' },
+  { field: 'parent', description: 'Parent organization' },
+  { field: 'website', description: 'Website URL' },
+];
+
+const PROJECT_FIELDS: FieldDef[] = [
+  { field: 'name', description: 'Project name' },
+  { field: 'organization', description: 'Organization reference' },
+  { field: 'start', description: 'Start date' },
+  { field: 'description', description: 'Project description' },
+  { field: 'end', description: 'End date' },
+  { field: 'skillsUsed', description: 'Skills used in this project' },
+  { field: 'persons', description: 'Persons involved' },
+];
+
+const CERTIFICATION_FIELDS: FieldDef[] = [
+  { field: 'name', description: 'Certification name' },
+  { field: 'issuer', description: 'Issuing organization' },
+  { field: 'date', description: 'Date obtained' },
+  { field: 'person', description: 'Person reference' },
+  { field: 'expires', description: 'Expiration date' },
+];
+
+const TANDEM_FIELDS: FieldDef[] = [
+  { field: 'partners', description: 'Partner references (exactly 2)' },
+  { field: 'sharedVision', description: 'Shared professional vision' },
+  { field: 'complementarySkills', description: 'Complementary skills description' },
+  { field: 'collaborationModel', description: 'Collaboration model description' },
+  { field: 'combinedNarrative', description: 'Combined professional narrative' },
+  { field: 'jointCompetencies', description: 'Joint competencies list' },
+];
+
+const FIELD_DEFS: Record<EntityType, FieldDef[]> = {
+  person: PERSON_FIELDS,
+  experience: EXPERIENCE_FIELDS,
+  skill: SKILL_FIELDS,
+  organization: ORGANIZATION_FIELDS,
+  project: PROJECT_FIELDS,
+  certification: CERTIFICATION_FIELDS,
+  tandem: TANDEM_FIELDS,
+};
+
+// --- Helpers ---
+
+/**
+ * Resolves a dot-notation field path on an object.
+ */
+function getNestedValue(obj: Record<string, unknown>, path: string): unknown {
+  const parts = path.split('.');
+  let current: unknown = obj;
+  for (const part of parts) {
+    if (current === null || current === undefined || typeof current !== 'object') {
+      return undefined;
+    }
+    current = (current as Record<string, unknown>)[part];
+  }
+  return current;
+}
+
+/**
+ * Checks whether a value counts as "filled" (not missing/empty).
+ */
+function isFilled(value: unknown): boolean {
+  if (value === undefined || value === null) return false;
+  if (typeof value === 'string' && value.trim() === '') return false;
+  if (Array.isArray(value) && value.length === 0) return false;
+  return true;
+}
+
+// --- Main Function ---
+
+/**
+ * Calculates the completeness score for an entity.
+ * Score = filledCount / totalCount (ratio of filled to total defined attributes).
+ */
+export function calculateCompleteness(entity: Entity): CompletenessResult {
+  const fieldDefs = FIELD_DEFS[entity.type];
+  if (!fieldDefs || fieldDefs.length === 0) {
+    return { score: 1.0, filledCount: 0, totalCount: 0, missingFields: [] };
+  }
+
+  const obj = entity as unknown as Record<string, unknown>;
+  const missingFields: string[] = [];
+  let filledCount = 0;
+
+  for (const def of fieldDefs) {
+    const value = getNestedValue(obj, def.field);
+    if (isFilled(value)) {
+      filledCount++;
+    } else {
+      missingFields.push(def.field);
+    }
+  }
+
+  const totalCount = fieldDefs.length;
+  const score = totalCount > 0 ? filledCount / totalCount : 1.0;
+
+  return { score, filledCount, totalCount, missingFields };
+}

privat/CV/src/review/prioritization.ts

@@ -0,0 +1,97 @@
+/**
+ * Prioritization — ranks entities for review based on completeness and staleness.
+ *
+ * Pure function, no I/O.
+ * Priority formula: priority = (1 - completenessScore) * 0.6 + staleness * 0.4
+ * where staleness = normalized days since modification (0 to 1, capped at 365 days).
+ */
+
+import type { Entity, EntityType } from '../schemas/types';
+import type { CompletenessResult } from './completeness-score';
+
+// --- Types ---
+
+export interface PrioritizedEntity {
+  entityId: string;
+  entityType: EntityType;
+  completenessScore: number;
+  lastModified: string;
+  /** Higher value = more urgent */
+  priority: number;
+  /** Human-readable explanation */
+  reason: string;
+}
+
+// --- Constants ---
+
+const MAX_STALENESS_DAYS = 365;
+const COMPLETENESS_WEIGHT = 0.6;
+const STALENESS_WEIGHT = 0.4;
+
+// --- Main Function ---
+
+/**
+ * Prioritizes entities for review.
+ * Lower completeness + older modification date = higher priority.
+ * Returns sorted list (highest priority first).
+ */
+export function prioritizeForReview(
+  entities: Array<{ entity: Entity; completeness: CompletenessResult }>,
+  now: Date = new Date()
+): PrioritizedEntity[] {
+  const results: PrioritizedEntity[] = entities.map(({ entity, completeness }) => {
+    const lastModified = entity.modified;
+    const daysSinceModified = getDaysSince(lastModified, now);
+    const staleness = Math.min(daysSinceModified / MAX_STALENESS_DAYS, 1.0);
+
+    const priority =
+      (1 - completeness.score) * COMPLETENESS_WEIGHT +
+      staleness * STALENESS_WEIGHT;
+
+    const reason = buildReason(completeness.score, daysSinceModified);
+
+    return {
+      entityId: entity.id,
+      entityType: entity.type,
+      completenessScore: completeness.score,
+      lastModified,
+      priority,
+      reason,
+    };
+  });
+
+  // Sort by priority descending (highest priority first)
+  results.sort((a, b) => b.priority - a.priority);
+
+  return results;
+}
+
+// --- Helpers ---
+
+function getDaysSince(isoDate: string, now: Date): number {
+  const modified = new Date(isoDate);
+  const diffMs = now.getTime() - modified.getTime();
+  return Math.max(0, Math.floor(diffMs / (1000 * 60 * 60 * 24)));
+}
+
+function buildReason(completenessScore: number, daysSinceModified: number): string {
+  const parts: string[] = [];
+
+  if (completenessScore < 0.5) {
+    parts.push(`low completeness (${Math.round(completenessScore * 100)}%)`);
+  } else if (completenessScore < 0.8) {
+    parts.push(`moderate completeness (${Math.round(completenessScore * 100)}%)`);
+  }
+
+  if (daysSinceModified > 180) {
+    parts.push(`not updated in ${daysSinceModified} days`);
+  } else if (daysSinceModified > 90) {
+    parts.push(`last updated ${daysSinceModified} days ago`);
+  }
+
+  if (parts.length === 0) {
+    return 'Routine review';
+  }
+
+  return parts.join('; ');
+}

privat/CV/src/review/review.test.ts

@@ -0,0 +1,219 @@
+import { describe, it, expect } from 'vitest';
+import fc from 'fast-check';
+import { calculateCompleteness } from './completeness-score';
+import { prioritizeForReview } from './prioritization';
+import type { Person, Entity } from '../schemas/types';
+
+// --- Arbitraries ---
+
+/** Generates a valid kebab-case ID */
+const kebabCaseId = fc
+  .array(
+    fc.stringMatching(/^[a-z0-9]{1,8}$/),
+    { minLength: 1, maxLength: 4 }
+  )
+  .map(parts => parts.join('-'));
+
+/** Generates a valid ISO date string */
+const isoDate = fc
+  .record({
+    year: fc.integer({ min: 1990, max: 2030 }),
+    month: fc.integer({ min: 1, max: 12 }),
+  })
+  .map(({ year, month }) => `${year}-${String(month).padStart(2, '0')}`);
+
+/** Generates a Person entity with varying completeness */
+const personWithVaryingCompleteness = fc.record({
+  id: kebabCaseId,
+  created: isoDate,
+  modified: isoDate,
+  hasContact: fc.boolean(),
+  hasSummary: fc.boolean(),
+  hasLanguages: fc.boolean(),
+  hasEducation: fc.boolean(),
+  hasSkills: fc.boolean(),
+  hasExperiences: fc.boolean(),
+  hasCertifications: fc.boolean(),
+}).map(fields => {
+  const person: Record<string, unknown> = {
+    id: fields.id,
+    type: 'person',
+    created: fields.created,
+    modified: fields.modified,
+    name: { first: 'Andre', last: 'Knie', display: 'Andre Knie' },
+  };
+
+  if (fields.hasContact) person.contact = { email: 'test@example.com' };
+  if (fields.hasSummary) person.summary = 'A professional summary.';
+  if (fields.hasLanguages) person.languages = [{ language: 'German', level: 'native' }];
+  if (fields.hasEducation) person.education = [{ institution: 'TU', degree: 'MSc', field: 'CS', start: '2000-09', end: '2004-06' }];
+  if (fields.hasSkills) person.skills = ['python', 'typescript'];
+  if (fields.hasExperiences) person.experiences = ['exp-1'];
+  if (fields.hasCertifications) person.certifications = ['cert-1'];
+
+  return person as unknown as Person;
+});
+
+/** Generates a fully complete Person entity */
+const fullPerson = fc.record({
+  id: kebabCaseId,
+  created: isoDate,
+  modified: isoDate,
+}).map(fields => ({
+  id: fields.id,
+  type: 'person' as const,
+  created: fields.created,
+  modified: fields.modified,
+  name: { first: 'Andre', last: 'Knie', display: 'Andre Knie' },
+  contact: { email: 'test@example.com', linkedin: 'linkedin.com/in/test' },
+  summary: 'Professional summary text.',
+  languages: [{ language: 'German', level: 'native' }],
+  education: [{ institution: 'TU Berlin', degree: 'MSc', field: 'CS', start: '2000-09', end: '2004-06' }],
+  skills: ['python', 'typescript'],
+  experiences: ['exp-1', 'exp-2'],
+  certifications: ['cert-1'],
+}));
+
+/** Generates a minimal Person entity (only required header + name) */
+const emptyPerson = fc.record({
+  id: kebabCaseId,
+  created: isoDate,
+  modified: isoDate,
+}).map(fields => ({
+  id: fields.id,
+  type: 'person' as const,
+  created: fields.created,
+  modified: fields.modified,
+  name: { first: 'Andre', last: 'Knie', display: 'Andre Knie' },
+}));
+
+// --- Property 13: Completeness score calculation ---
+
+describe('Property 13: Completeness score calculation', () => {
+  it('completeness score equals ratio of filled attributes to total defined attributes', () => {
+    fc.assert(
+      fc.property(personWithVaryingCompleteness, (person) => {
+        const result = calculateCompleteness(person);
+
+        // Score must equal filledCount / totalCount
+        const expectedScore = result.totalCount > 0
+          ? result.filledCount / result.totalCount
+          : 1.0;
+        expect(result.score).toBeCloseTo(expectedScore, 10);
+
+        // filledCount + missingFields.length must equal totalCount
+        expect(result.filledCount + result.missingFields.length).toBe(result.totalCount);
+
+        // Score must be between 0 and 1
+        expect(result.score).toBeGreaterThanOrEqual(0.0);
+        expect(result.score).toBeLessThanOrEqual(1.0);
+      }),
+      { numRuns: 100 }
+    );
+  });
+
+  it('a profile with all attributes filled scores 1.0', () => {
+    fc.assert(
+      fc.property(fullPerson, (person) => {
+        const result = calculateCompleteness(person as unknown as Entity);
+        expect(result.score).toBe(1.0);
+        expect(result.missingFields).toHaveLength(0);
+      }),
+      { numRuns: 100 }
+    );
+  });
+
+  it('a profile with only required header fields scores close to 0.0', () => {
+    fc.assert(
+      fc.property(emptyPerson, (person) => {
+        const result = calculateCompleteness(person as unknown as Entity);
+        // With only name fields filled (3 out of 10 total person fields), score should be low
+        expect(result.score).toBeLessThan(0.5);
+        expect(result.missingFields.length).toBeGreaterThan(0);
+      }),
+      { numRuns: 100 }
+    );
+  });
+
+  /**
+   * Validates: Requirements 7.3
+   */
+});
+
+// --- Property 14: Review prioritization ordering ---
+
+describe('Property 14: Review prioritization ordering', () => {
+  it('entities with lower completeness and older modification dates rank higher than entities with higher completeness and recent modifications', () => {
+    // Generate a pair: one entity with low completeness + old date, another with high completeness + recent date
+    const entityPair = fc.record({
+      id1: kebabCaseId,
+      id2: kebabCaseId,
+      // Low completeness entity: modified long ago
+      daysAgoOld: fc.integer({ min: 100, max: 365 }),
+      // High completeness entity: modified recently
+      daysAgoRecent: fc.integer({ min: 0, max: 30 }),
+    }).filter(f => f.id1 !== f.id2);
+
+    fc.assert(
+      fc.property(entityPair, (pair) => {
+        const now = new Date('2025-06-01');
+
+        // Entity A: low completeness, old modification
+        const oldDate = new Date(now.getTime() - pair.daysAgoOld * 24 * 60 * 60 * 1000);
+        const oldModified = oldDate.toISOString().slice(0, 10);
+
+        // Entity B: high completeness, recent modification
+        const recentDate = new Date(now.getTime() - pair.daysAgoRecent * 24 * 60 * 60 * 1000);
+        const recentModified = recentDate.toISOString().slice(0, 10);
+
+        // Entity A: minimal person (low completeness)
+        const entityA: Entity = {
+          id: pair.id1,
+          type: 'person',
+          created: '2020-01-01',
+          modified: oldModified,
+          name: { first: 'Low', last: 'Complete', display: 'Low Complete' },
+        } as unknown as Entity;
+
+        // Entity B: full person (high completeness)
+        const entityB: Entity = {
+          id: pair.id2,
+          type: 'person',
+          created: '2020-01-01',
+          modified: recentModified,
+          name: { first: 'High', last: 'Complete', display: 'High Complete' },
+          contact: { email: 'test@example.com' },
+          summary: 'Full summary.',
+          languages: [{ language: 'English', level: 'native' }],
+          education: [{ institution: 'MIT', degree: 'PhD', field: 'CS', start: '2010-09', end: '2014-06' }],
+          skills: ['python'],
+          experiences: ['exp-1'],
+          certifications: ['cert-1'],
+        } as unknown as Entity;
+
+        const completenessA = calculateCompleteness(entityA);
+        const completenessB = calculateCompleteness(entityB);
+
+        const results = prioritizeForReview(
+          [
+            { entity: entityA, completeness: completenessA },
+            { entity: entityB, completeness: completenessB },
+          ],
+          now
+        );
+
+        // Entity A (lower completeness + older) should rank higher (appear first)
+        expect(results[0].entityId).toBe(pair.id1);
+        expect(results[1].entityId).toBe(pair.id2);
+
+        // Priority values should reflect the ordering
+        expect(results[0].priority).toBeGreaterThan(results[1].priority);
+      }),
+      { numRuns: 100 }
+    );
+  });
+
+  /**
+   * Validates: Requirements 7.2
+   */
+});

privat/CV/src/schemas/types.ts

@@ -0,0 +1,213 @@
+/**
+ * Personal Knowledge Base - Entity Type Definitions
+ *
+ * TypeScript interfaces for all knowledge graph entity types.
+ * Properties use camelCase (the YAML files use kebab-case; these represent the parsed/deserialized form).
+ */
+
+// --- Entity Types ---
+
+/**
+ * Union type of all supported entity types in the knowledge graph.
+ */
+export type EntityType =
+  | 'person'
+  | 'experience'
+  | 'skill'
+  | 'organization'
+  | 'project'
+  | 'certification'
+  | 'tandem';
+
+/**
+ * Relationship types between entities in the knowledge graph.
+ */
+export type RelationshipType =
+  | 'has_skill'
+  | 'worked_at'
+  | 'collaborated_with'
+  | 'applied_for'
+  | 'partners_with';
+
+// --- Common Header ---
+
+/**
+ * Common header present on all entity files.
+ */
+export interface EntityHeader {
+  /** Unique identifier in kebab-case */
+  id: string;
+  /** The entity type discriminator */
+  type: EntityType;
+  /** ISO-8601 date when the entity was created */
+  created: string;
+  /** ISO-8601 date when the entity was last modified */
+  modified: string;
+}
+
+// --- Person ---
+
+export interface PersonName {
+  first: string;
+  last: string;
+  display: string;
+}
+
+export interface PersonContact {
+  email?: string;
+  linkedin?: string;
+  location?: string;
+}
+
+export interface Language {
+  language: string;
+  level: string;
+}
+
+export interface Education {
+  institution: string;
+  degree: string;
+  field: string;
+  start: string;
+  end: string;
+}
+
+export interface Person extends EntityHeader {
+  type: 'person';
+  name: PersonName;
+  contact?: PersonContact;
+  summary?: string;
+  languages?: Language[];
+  education?: Education[];
+  /** References to Skill entity IDs */
+  skills?: string[];
+  /** References to Experience entity IDs */
+  experiences?: string[];
+  /** References to Certification entity IDs */
+  certifications?: string[];
+  publications?: string[];
+}
+
+// --- Experience ---
+
+export interface Experience extends EntityHeader {
+  type: 'experience';
+  title: string;
+  /** Reference to Organization entity ID */
+  organization: string;
+  start: string;
+  end: string | null;
+  description?: string;
+  achievements?: string[];
+  /** References to Skill entity IDs */
+  skillsUsed?: string[];
+  /** References to Project entity IDs */
+  projects?: string[];
+}
+
+// --- Skill ---
+
+export type SkillCategory =
+  | 'programming-language'
+  | 'framework'
+  | 'methodology'
+  | 'soft-skill'
+  | 'domain';
+
+export type SkillLevel =
+  | 'beginner'
+  | 'intermediate'
+  | 'advanced'
+  | 'expert';
+
+export interface Skill extends EntityHeader {
+  type: 'skill';
+  name: string;
+  category: SkillCategory;
+  level: SkillLevel;
+  years?: number;
+  context?: string;
+}
+
+// --- Organization ---
+
+export interface Organization extends EntityHeader {
+  type: 'organization';
+  name: string;
+  industry: string;
+  /** Reference to parent Organization entity ID */
+  parent?: string;
+  website?: string;
+}
+
+// --- Project ---
+
+export interface Project extends EntityHeader {
+  type: 'project';
+  name: string;
+  description?: string;
+  /** Reference to Organization entity ID */
+  organization: string;
+  start: string;
+  end?: string;
+  /** References to Skill entity IDs */
+  skillsUsed?: string[];
+  /** References to Person entity IDs */
+  persons?: string[];
+}
+
+// --- Certification ---
+
+export interface Certification extends EntityHeader {
+  type: 'certification';
+  name: string;
+  issuer: string;
+  date: string;
+  expires?: string;
+  /** Reference to Person entity ID */
+  person: string;
+}
+
+// --- Tandem ---
+
+export interface Tandem extends EntityHeader {
+  type: 'tandem';
+  /** Exactly 2 Person entity IDs */
+  partners: [string, string];
+  sharedVision: string;
+  complementarySkills: string;
+  collaborationModel: string;
+  combinedNarrative?: string;
+  jointCompetencies?: string[];
+}
+
+// --- Graph Index ---
+
+export interface GraphEntity {
+  id: string;
+  type: EntityType;
+  name: string;
+}
+
+export interface GraphRelationship {
+  from: string;
+  to: string;
+  type: RelationshipType;
+  context?: string;
+}
+
+export interface GraphIndex {
+  entities: GraphEntity[];
+  relationships: GraphRelationship[];
+}
+
+// --- Union type for any entity ---
+
+export type Entity =
+  | Person
+  | Experience
+  | Skill
+  | Organization
+  | Project
+  | Certification
+  | Tandem;

privat/CV/src/schemas/validate.test.ts

@@ -0,0 +1,661 @@
+import { describe, it, expect } from 'vitest';
+import {
+  validateEntity,
+  validatePerson,
+  validateExperience,
+  validateSkill,
+  validateOrganization,
+  validateProject,
+  validateCertification,
+  validateTandem,
+  isKebabCase,
+  isValidDate,
+  isTemporallyConsistent,
+  ValidationResult,
+} from './validate';
+
+// --- Helper: minimal valid entity headers ---
+const baseHeader = (type: string) => ({
+  id: 'test-entity',
+  type,
+  created: '2025-01-15',
+  modified: '2025-01-15',
+});
+
+describe('isKebabCase', () => {
+  it('accepts valid kebab-case strings', () => {
+    expect(isKebabCase('hello')).toBe(true);
+    expect(isKebabCase('hello-world')).toBe(true);
+    expect(isKebabCase('a-b-c')).toBe(true);
+    expect(isKebabCase('test123')).toBe(true);
+    expect(isKebabCase('my-skill-2')).toBe(true);
+  });
+
+  it('rejects invalid kebab-case strings', () => {
+    expect(isKebabCase('')).toBe(false);
+    expect(isKebabCase('-leading')).toBe(false);
+    expect(isKebabCase('trailing-')).toBe(false);
+    expect(isKebabCase('UPPER')).toBe(false);
+    expect(isKebabCase('camelCase')).toBe(false);
+    expect(isKebabCase('has space')).toBe(false);
+    expect(isKebabCase('double--hyphen')).toBe(false);
+    expect(isKebabCase('under_score')).toBe(false);
+  });
+});
+
+describe('isValidDate', () => {
+  it('accepts valid ISO dates', () => {
+    expect(isValidDate('2025-01-15')).toBe(true);
+    expect(isValidDate('2025-01')).toBe(true);
+    expect(isValidDate('2020-12-31')).toBe(true);
+    expect(isValidDate('1999-06')).toBe(true);
+  });
+
+  it('rejects invalid dates', () => {
+    expect(isValidDate('')).toBe(false);
+    expect(isValidDate('2025')).toBe(false);
+    expect(isValidDate('2025-13')).toBe(false);
+    expect(isValidDate('2025-00')).toBe(false);
+    expect(isValidDate('not-a-date')).toBe(false);
+    expect(isValidDate('2025/01/15')).toBe(false);
+    expect(isValidDate('01-2025')).toBe(false);
+  });
+});
+
+describe('isTemporallyConsistent', () => {
+  it('returns true when end is null or undefined', () => {
+    expect(isTemporallyConsistent('2025-01', null)).toBe(true);
+    expect(isTemporallyConsistent('2025-01', undefined)).toBe(true);
+  });
+
+  it('returns true when start <= end', () => {
+    expect(isTemporallyConsistent('2020-01', '2025-01')).toBe(true);
+    expect(isTemporallyConsistent('2025-01', '2025-01')).toBe(true);
+    expect(isTemporallyConsistent('2025-01-01', '2025-01-02')).toBe(true);
+  });
+
+  it('returns false when start > end', () => {
+    expect(isTemporallyConsistent('2025-06', '2025-01')).toBe(false);
+    expect(isTemporallyConsistent('2025-01-15', '2025-01-01')).toBe(false);
+  });
+});
+
+describe('validateEntity', () => {
+  it('rejects null/undefined', () => {
+    expect(validateEntity(null).valid).toBe(false);
+    expect(validateEntity(undefined).valid).toBe(false);
+  });
+
+  it('rejects non-objects', () => {
+    expect(validateEntity('string').valid).toBe(false);
+    expect(validateEntity(42).valid).toBe(false);
+  });
+
+  it('rejects missing type', () => {
+    const result = validateEntity({ id: 'test' });
+    expect(result.valid).toBe(false);
+    expect(result.errors).toContain('Missing required field: type');
+  });
+
+  it('rejects invalid type', () => {
+    const result = validateEntity({ ...baseHeader('invalid-type') });
+    expect(result.valid).toBe(false);
+  });
+
+  it('dispatches to correct validator', () => {
+    const person = {
+      ...baseHeader('person'),
+      name: { first: 'Andre', last: 'Knie', display: 'Andre Knie' },
+    };
+    expect(validateEntity(person).valid).toBe(true);
+  });
+});
+
+describe('validatePerson', () => {
+  it('accepts a valid person', () => {
+    const person = {
+      ...baseHeader('person'),
+      name: { first: 'Andre', last: 'Knie', display: 'Andre Knie' },
+    };
+    expect(validatePerson(person).valid).toBe(true);
+  });
+
+  it('rejects missing name', () => {
+    const result = validatePerson(baseHeader('person'));
+    expect(result.valid).toBe(false);
+    expect(result.errors).toContain('Missing required field: name');
+  });
+
+  it('rejects missing name subfields', () => {
+    const person = { ...baseHeader('person'), name: { first: 'Andre' } };
+    const result = validatePerson(person);
+    expect(result.valid).toBe(false);
+    expect(result.errors).toContain('Missing required field: name.last');
+    expect(result.errors).toContain('Missing required field: name.display');
+  });
+});
+
+describe('validateExperience', () => {
+  it('accepts a valid experience', () => {
+    const exp = {
+      ...baseHeader('experience'),
+      title: 'Lead Developer',
+      organization: 'db-cargo',
+      start: '2023-04',
+      end: null,
+    };
+    expect(validateExperience(exp).valid).toBe(true);
+  });
+
+  it('rejects missing required fields', () => {
+    const result = validateExperience(baseHeader('experience'));
+    expect(result.valid).toBe(false);
+    expect(result.errors).toContain('Missing required field: title');
+    expect(result.errors).toContain('Missing required field: organization');
+    expect(result.errors).toContain('Missing required field: start');
+  });
+
+  it('detects temporal inconsistency', () => {
+    const exp = {
+      ...baseHeader('experience'),
+      title: 'Dev',
+      organization: 'org',
+      start: '2025-06',
+      end: '2025-01',
+    };
+    const result = validateExperience(exp);
+    expect(result.valid).toBe(false);
+    expect(result.errors.some(e => e.includes('Temporal inconsistency'))).toBe(true);
+  });
+});
+
+describe('validateSkill', () => {
+  it('accepts a valid skill', () => {
+    const skill = {
+      ...baseHeader('skill'),
+      name: 'Python',
+      category: 'programming-language',
+      level: 'expert',
+    };
+    expect(validateSkill(skill).valid).toBe(true);
+  });
+
+  it('rejects invalid category', () => {
+    const skill = {
+      ...baseHeader('skill'),
+      name: 'Python',
+      category: 'invalid-cat',
+      level: 'expert',
+    };
+    const result = validateSkill(skill);
+    expect(result.valid).toBe(false);
+    expect(result.errors.some(e => e.includes('category'))).toBe(true);
+  });
+
+  it('rejects invalid level', () => {
+    const skill = {
+      ...baseHeader('skill'),
+      name: 'Python',
+      category: 'framework',
+      level: 'master',
+    };
+    const result = validateSkill(skill);
+    expect(result.valid).toBe(false);
+    expect(result.errors.some(e => e.includes('level'))).toBe(true);
+  });
+});
+
+describe('validateOrganization', () => {
+  it('accepts a valid organization', () => {
+    const org = {
+      ...baseHeader('organization'),
+      name: 'DB Cargo AG',
+      industry: 'logistics',
+    };
+    expect(validateOrganization(org).valid).toBe(true);
+  });
+
+  it('rejects missing fields', () => {
+    const result = validateOrganization(baseHeader('organization'));
+    expect(result.valid).toBe(false);
+    expect(result.errors).toContain('Missing required field: name');
+    expect(result.errors).toContain('Missing required field: industry');
+  });
+});
+
+describe('validateProject', () => {
+  it('accepts a valid project', () => {
+    const project = {
+      ...baseHeader('project'),
+      name: 'AI Platform',
+      organization: 'db-cargo',
+      start: '2024-01',
+    };
+    expect(validateProject(project).valid).toBe(true);
+  });
+
+  it('detects temporal inconsistency', () => {
+    const project = {
+      ...baseHeader('project'),
+      name: 'AI Platform',
+      organization: 'db-cargo',
+      start: '2025-06',
+      end: '2024-01',
+    };
+    const result = validateProject(project);
+    expect(result.valid).toBe(false);
+    expect(result.errors.some(e => e.includes('Temporal inconsistency'))).toBe(true);
+  });
+});
+
+describe('validateCertification', () => {
+  it('accepts a valid certification', () => {
+    const cert = {
+      ...baseHeader('certification'),
+      name: 'AWS Solutions Architect',
+      issuer: 'Amazon Web Services',
+      date: '2024-03',
+      person: 'andre-knie',
+    };
+    expect(validateCertification(cert).valid).toBe(true);
+  });
+
+  it('rejects missing fields', () => {
+    const result = validateCertification(baseHeader('certification'));
+    expect(result.valid).toBe(false);
+    expect(result.errors).toContain('Missing required field: name');
+    expect(result.errors).toContain('Missing required field: issuer');
+    expect(result.errors).toContain('Missing required field: date');
+    expect(result.errors).toContain('Missing required field: person');
+  });
+});
+
+describe('validateTandem', () => {
+  it('accepts a valid tandem', () => {
+    const tandem = {
+      ...baseHeader('tandem'),
+      partners: ['andre-knie', 'claudia-froldi'],
+      sharedVision: 'Shared vision text',
+      complementarySkills: 'Complementary skills text',
+      collaborationModel: 'Collaboration model text',
+    };
+    expect(validateTandem(tandem).valid).toBe(true);
+  });
+
+  it('rejects partners with wrong count', () => {
+    const tandem = {
+      ...baseHeader('tandem'),
+      partners: ['only-one'],
+      sharedVision: 'Vision',
+      complementarySkills: 'Skills',
+      collaborationModel: 'Model',
+    };
+    const result = validateTandem(tandem);
+    expect(result.valid).toBe(false);
+    expect(result.errors.some(e => e.includes('exactly 2'))).toBe(true);
+  });
+
+  it('rejects non-array partners', () => {
+    const tandem = {
+      ...baseHeader('tandem'),
+      partners: 'not-an-array',
+      sharedVision: 'Vision',
+      complementarySkills: 'Skills',
+      collaborationModel: 'Model',
+    };
+    const result = validateTandem(tandem);
+    expect(result.valid).toBe(false);
+    expect(result.errors.some(e => e.includes('must be an array'))).toBe(true);
+  });
+
+  it('rejects missing tandem-specific fields', () => {
+    const tandem = {
+      ...baseHeader('tandem'),
+      partners: ['a', 'b'],
+    };
+    const result = validateTandem(tandem);
+    expect(result.valid).toBe(false);
+    expect(result.errors).toContain('Missing required field: sharedVision');
+    expect(result.errors).toContain('Missing required field: complementarySkills');
+    expect(result.errors).toContain('Missing required field: collaborationModel');
+  });
+
+  it('rejects invalid id format in common fields', () => {
+    const tandem = {
+      id: 'Invalid-ID',
+      type: 'tandem',
+      created: '2025-01-15',
+      modified: '2025-01-15',
+      partners: ['a', 'b'],
+      sharedVision: 'Vision',
+      complementarySkills: 'Skills',
+      collaborationModel: 'Model',
+    };
+    const result = validateTandem(tandem);
+    expect(result.valid).toBe(false);
+    expect(result.errors.some(e => e.includes('kebab-case'))).toBe(true);
+  });
+});
+
+// --- Property-Based Tests (fast-check) ---
+
+import fc from 'fast-check';
+
+// --- Arbitraries ---
+
+/** Generates a valid kebab-case ID */
+const kebabCaseId = fc
+  .array(
+    fc.stringMatching(/^[a-z0-9]{1,8}$/),
+    { minLength: 1, maxLength: 4 }
+  )
+  .map(parts => parts.join('-'));
+
+/** Generates a valid ISO date (YYYY-MM or YYYY-MM-DD) */
+const isoDate = fc.oneof(
+  fc.record({
+    year: fc.integer({ min: 1990, max: 2030 }),
+    month: fc.integer({ min: 1, max: 12 }),
+  }).map(({ year, month }) => `${year}-${String(month).padStart(2, '0')}`),
+  fc.record({
+    year: fc.integer({ min: 1990, max: 2030 }),
+    month: fc.integer({ min: 1, max: 12 }),
+    day: fc.integer({ min: 1, max: 28 }),
+  }).map(({ year, month, day }) => `${year}-${String(month).padStart(2, '0')}-${String(day).padStart(2, '0')}`)
+);
+
+/** Generates a valid entity header */
+const entityHeader = (type: string) =>
+  fc.record({
+    id: kebabCaseId,
+    type: fc.constant(type),
+    created: isoDate,
+    modified: isoDate,
+  });
+
+/** Generates a valid Person entity */
+const personArb = entityHeader('person').chain(header =>
+  fc.record({
+    first: fc.string({ minLength: 1, maxLength: 20 }).filter(s => s.trim().length > 0),
+    last: fc.string({ minLength: 1, maxLength: 20 }).filter(s => s.trim().length > 0),
+    display: fc.string({ minLength: 1, maxLength: 40 }).filter(s => s.trim().length > 0),
+  }).map(name => ({
+    ...header,
+    name: { first: name.first, last: name.last, display: name.display },
+  }))
+);
+
+/** Generates a valid Skill entity */
+const skillArb = entityHeader('skill').chain(header =>
+  fc.record({
+    name: fc.string({ minLength: 1, maxLength: 30 }).filter(s => s.trim().length > 0),
+    category: fc.constantFrom('programming-language', 'framework', 'methodology', 'soft-skill', 'domain'),
+    level: fc.constantFrom('beginner', 'intermediate', 'advanced', 'expert'),
+  }).map(fields => ({ ...header, ...fields }))
+);
+
+/** Generates a valid Organization entity */
+const orgArb = entityHeader('organization').chain(header =>
+  fc.record({
+    name: fc.string({ minLength: 1, maxLength: 30 }).filter(s => s.trim().length > 0),
+    industry: fc.string({ minLength: 1, maxLength: 20 }).filter(s => s.trim().length > 0),
+  }).map(fields => ({ ...header, ...fields }))
+);
+
+/** Generates a valid Experience entity */
+const experienceArb = entityHeader('experience').chain(header =>
+  fc.record({
+    title: fc.string({ minLength: 1, maxLength: 30 }).filter(s => s.trim().length > 0),
+    organization: kebabCaseId,
+    start: isoDate,
+  }).map(fields => ({ ...header, ...fields, end: null }))
+);
+
+/** Generates a valid Project entity */
+const projectArb = entityHeader('project').chain(header =>
+  fc.record({
+    name: fc.string({ minLength: 1, maxLength: 30 }).filter(s => s.trim().length > 0),
+    organization: kebabCaseId,
+    start: isoDate,
+  }).map(fields => ({ ...header, ...fields }))
+);
+
+/** Generates a valid Certification entity */
+const certArb = entityHeader('certification').chain(header =>
+  fc.record({
+    name: fc.string({ minLength: 1, maxLength: 30 }).filter(s => s.trim().length > 0),
+    issuer: fc.string({ minLength: 1, maxLength: 30 }).filter(s => s.trim().length > 0),
+    date: isoDate,
+    person: kebabCaseId,
+  }).map(fields => ({ ...header, ...fields }))
+);
+
+/** Generates a valid Tandem entity */
+const tandemArb = entityHeader('tandem').chain(header =>
+  fc.record({
+    partner1: kebabCaseId,
+    partner2: kebabCaseId,
+    sharedVision: fc.string({ minLength: 1, maxLength: 50 }).filter(s => s.trim().length > 0),
+    complementarySkills: fc.string({ minLength: 1, maxLength: 50 }).filter(s => s.trim().length > 0),
+    collaborationModel: fc.string({ minLength: 1, maxLength: 50 }).filter(s => s.trim().length > 0),
+  }).map(fields => ({
+    ...header,
+    partners: [fields.partner1, fields.partner2] as [string, string],
+    sharedVision: fields.sharedVision,
+    complementarySkills: fields.complementarySkills,
+    collaborationModel: fields.collaborationModel,
+  }))
+);
+
+/** Generates any valid entity */
+const anyValidEntity = fc.oneof(
+  personArb,
+  skillArb,
+  orgArb,
+  experienceArb,
+  projectArb,
+  certArb,
+  tandemArb,
+);
+
+// --- Property 1: Entity serialization round-trip ---
+
+describe('Property 1: Entity serialization round-trip', () => {
+  it('JSON.parse(JSON.stringify(entity)) produces an equivalent entity that passes validation', () => {
+    fc.assert(
+      fc.property(anyValidEntity, (entity) => {
+        const roundTripped = JSON.parse(JSON.stringify(entity));
+        // All attributes preserved
+        expect(roundTripped).toEqual(entity);
+        // Still passes validation
+        const result = validateEntity(roundTripped);
+        expect(result.valid).toBe(true);
+      }),
+      { numRuns: 100 }
+    );
+  });
+
+  /**
+   * Validates: Requirements 2.1, 8.2
+   */
+});
+
+// --- Property 2: Entity schema validation ---
+
+describe('Property 2: Entity schema validation', () => {
+  it('accepts any valid entity with all required attributes present and correctly typed', () => {
+    fc.assert(
+      fc.property(anyValidEntity, (entity) => {
+        const result = validateEntity(entity);
+        expect(result.valid).toBe(true);
+        expect(result.errors).toHaveLength(0);
+      }),
+      { numRuns: 100 }
+    );
+  });
+
+  it('rejects entities missing required fields', () => {
+    const entityTypes = ['person', 'experience', 'skill', 'organization', 'project', 'certification', 'tandem'] as const;
+    fc.assert(
+      fc.property(
+        fc.constantFrom(...entityTypes),
+        kebabCaseId,
+        isoDate,
+        isoDate,
+        (type, id, created, modified) => {
+          // Entity with only header fields — missing type-specific required fields
+          const entity = { id, type, created, modified };
+          const result = validateEntity(entity);
+          // Person needs name, experience needs title/org/start, etc.
+          // All types have additional required fields beyond the header
+          expect(result.valid).toBe(false);
+          expect(result.errors.length).toBeGreaterThan(0);
+        }
+      ),
+      { numRuns: 100 }
+    );
+  });
+
+  /**
+   * Validates: Requirements 1.1, 1.3
+   */
+});
+
+// --- Property 3: Temporal consistency ---
+
+describe('Property 3: Temporal consistency', () => {
+  it('validation passes when start <= end for time-bound entities', () => {
+    fc.assert(
+      fc.property(
+        kebabCaseId,
+        isoDate,
+        isoDate,
+        fc.constantFrom('experience', 'project'),
+        (id, date1, date2, type) => {
+          const [start, end] = date1 <= date2 ? [date1, date2] : [date2, date1];
+          const entity: Record<string, unknown> = {
+            id,
+            type,
+            created: start,
+            modified: start,
+            start,
+            end,
+          };
+          if (type === 'experience') {
+            entity.title = 'Test Role';
+            entity.organization = 'test-org';
+          } else {
+            entity.name = 'Test Project';
+            entity.organization = 'test-org';
+          }
+          const result = validateEntity(entity);
+          // Should not have temporal inconsistency errors
+          const temporalErrors = result.errors.filter(e => e.includes('Temporal inconsistency'));
+          expect(temporalErrors).toHaveLength(0);
+        }
+      ),
+      { numRuns: 100 }
+    );
+  });
+
+  it('validation fails when start > end for time-bound entities', () => {
+    fc.assert(
+      fc.property(
+        kebabCaseId,
+        fc.record({
+          year: fc.integer({ min: 1990, max: 2025 }),
+          month: fc.integer({ min: 1, max: 12 }),
+        }),
+        fc.integer({ min: 1, max: 60 }),
+        fc.constantFrom('experience', 'project'),
+        (id, startParts, monthsLater, type) => {
+          const startStr = `${startParts.year}-${String(startParts.month).padStart(2, '0')}`;
+          // Compute an end date that is strictly before start
+          const endYear = startParts.year - Math.ceil(monthsLater / 12);
+          const endMonth = ((startParts.month - (monthsLater % 12) - 1 + 12) % 12) + 1;
+          const endStr = `${endYear}-${String(endMonth).padStart(2, '0')}`;
+
+          // Only test when end is actually before start (string comparison)
+          fc.pre(endStr < startStr);
+
+          const entity: Record<string, unknown> = {
+            id,
+            type,
+            created: startStr,
+            modified: startStr,
+            start: startStr,
+            end: endStr,
+          };
+          if (type === 'experience') {
+            entity.title = 'Test Role';
+            entity.organization = 'test-org';
+          } else {
+            entity.name = 'Test Project';
+            entity.organization = 'test-org';
+          }
+          const result = validateEntity(entity);
+          expect(result.valid).toBe(false);
+          expect(result.errors.some(e => e.includes('Temporal inconsistency'))).toBe(true);
+        }
+      ),
+      { numRuns: 100 }
+    );
+  });
+
+  /**
+   * Validates: Requirements 1.4
+   */
+});
+
+// --- Property 15: File naming convention ---
+
+describe('Property 15: File naming convention', () => {
+  it('any valid entity ID produces a file name matching <entity-id>.yaml with kebab-case', () => {
+    fc.assert(
+      fc.property(kebabCaseId, (id) => {
+        const fileName = `${id}.yaml`;
+        // File name matches pattern: lowercase letters, numbers, hyphens, ending in .yaml
+        expect(fileName).toMatch(/^[a-z0-9]+(-[a-z0-9]+)*\.yaml$/);
+        // The ID itself is valid kebab-case
+        expect(isKebabCase(id)).toBe(true);
+      }),
+      { numRuns: 100 }
+    );
+  });
+
+  it('non-kebab-case IDs are rejected by validation', () => {
+    const invalidIds = fc.oneof(
+      fc.constant(''),
+      fc.constant('-leading'),
+      fc.constant('trailing-'),
+      fc.constant('UPPERCASE'),
+      fc.constant('camelCase'),
+      fc.constant('has space'),
+      fc.constant('double--hyphen'),
+      fc.constant('under_score'),
+      fc.stringMatching(/^[A-Z]{1,10}$/),
+    );
+
+    fc.assert(
+      fc.property(invalidIds, isoDate, isoDate, (id, created, modified) => {
+        const entity = {
+          id,
+          type: 'skill',
+          created,
+          modified,
+          name: 'Test',
+          category: 'framework',
+          level: 'expert',
+        };
+        const result = validateEntity(entity);
+        expect(result.valid).toBe(false);
+        expect(result.errors.some(e => e.includes('kebab-case') || e.includes('id'))).toBe(true);
+      }),
+      { numRuns: 100 }
+    );
+  });
+
+  /**
+   * Validates: Requirements 9.2
+   */
+});

privat/CV/src/schemas/validate.ts

@@ -0,0 +1,357 @@
+/**
+ * Personal Knowledge Base - Entity Validation Functions
+ *
+ * Validates entity objects against their schema definitions.
+ * Returns descriptive errors listing missing or invalid fields.
+ */
+
+import type {
+  EntityType,
+  SkillCategory,
+  SkillLevel,
+} from './types';
+
+// --- Validation Result ---
+
+export interface ValidationResult {
+  valid: boolean;
+  errors: string[];
+}
+
+// --- Constants ---
+
+const VALID_ENTITY_TYPES: EntityType[] = [
+  'person',
+  'experience',
+  'skill',
+  'organization',
+  'project',
+  'certification',
+  'tandem',
+];
+
+const VALID_SKILL_CATEGORIES: SkillCategory[] = [
+  'programming-language',
+  'framework',
+  'methodology',
+  'soft-skill',
+  'domain',
+];
+
+const VALID_SKILL_LEVELS: SkillLevel[] = [
+  'beginner',
+  'intermediate',
+  'advanced',
+  'expert',
+];
+
+// --- Helper Functions ---
+
+/**
+ * Validates kebab-case format: lowercase letters, numbers, and hyphens only.
+ * No leading or trailing hyphens allowed.
+ */
+export function isKebabCase(id: string): boolean {
+  if (typeof id !== 'string' || id.length === 0) return false;
+  return /^[a-z0-9]+(-[a-z0-9]+)*$/.test(id);
+}
+
+/**
+ * Validates ISO date format: YYYY-MM-DD or YYYY-MM.
+ */
+export function isValidDate(date: string): boolean {
+  if (typeof date !== 'string') return false;
+  return /^\d{4}-(0[1-9]|1[0-2])(-([0-2]\d|3[01]))?$/.test(date);
+}
+
+/**
+ * Validates temporal consistency: start <= end when both are present.
+ * Returns true if end is null/undefined (open-ended) or start <= end.
+ */
+export function isTemporallyConsistent(
+  start: string,
+  end: string | null | undefined
+): boolean {
+  if (end === null || end === undefined) return true;
+  return start <= end;
+}
+
+// --- Common Validation ---
+
+function validateCommonFields(entity: Record<string, unknown>): string[] {
+  const errors: string[] = [];
+
+  if (!entity.id) {
+    errors.push('Missing required field: id');
+  } else if (typeof entity.id !== 'string') {
+    errors.push('Field "id" must be a string');
+  } else if (!isKebabCase(entity.id)) {
+    errors.push('Field "id" must be in kebab-case format (lowercase letters, numbers, hyphens only, no leading/trailing hyphens)');
+  }
+
+  if (!entity.type) {
+    errors.push('Missing required field: type');
+  } else if (typeof entity.type !== 'string') {
+    errors.push('Field "type" must be a string');
+  } else if (!VALID_ENTITY_TYPES.includes(entity.type as EntityType)) {
+    errors.push(`Field "type" must be one of: ${VALID_ENTITY_TYPES.join(', ')}`);
+  }
+
+  if (!entity.created) {
+    errors.push('Missing required field: created');
+  } else if (typeof entity.created !== 'string') {
+    errors.push('Field "created" must be a string');
+  } else if (!isValidDate(entity.created)) {
+    errors.push('Field "created" must be a valid ISO date (YYYY-MM-DD or YYYY-MM)');
+  }
+
+  if (!entity.modified) {
+    errors.push('Missing required field: modified');
+  } else if (typeof entity.modified !== 'string') {
+    errors.push('Field "modified" must be a string');
+  } else if (!isValidDate(entity.modified)) {
+    errors.push('Field "modified" must be a valid ISO date (YYYY-MM-DD or YYYY-MM)');
+  }
+
+  return errors;
+}
+
+// --- Entity-Specific Validators ---
+
+export function validatePerson(entity: Record<string, unknown>): ValidationResult {
+  const errors = validateCommonFields(entity);
+
+  if (!entity.name) {
+    errors.push('Missing required field: name');
+  } else if (typeof entity.name !== 'object' || entity.name === null) {
+    errors.push('Field "name" must be an object');
+  } else {
+    const name = entity.name as Record<string, unknown>;
+    if (!name.first || typeof name.first !== 'string') {
+      errors.push('Missing required field: name.first');
+    }
+    if (!name.last || typeof name.last !== 'string') {
+      errors.push('Missing required field: name.last');
+    }
+    if (!name.display || typeof name.display !== 'string') {
+      errors.push('Missing required field: name.display');
+    }
+  }
+
+  return { valid: errors.length === 0, errors };
+}
+
+export function validateExperience(entity: Record<string, unknown>): ValidationResult {
+  const errors = validateCommonFields(entity);
+
+  if (!entity.title || typeof entity.title !== 'string') {
+    errors.push('Missing required field: title');
+  }
+
+  if (!entity.organization || typeof entity.organization !== 'string') {
+    errors.push('Missing required field: organization');
+  }
+
+  if (!entity.start) {
+    errors.push('Missing required field: start');
+  } else if (typeof entity.start !== 'string') {
+    errors.push('Field "start" must be a string');
+  } else if (!isValidDate(entity.start)) {
+    errors.push('Field "start" must be a valid ISO date (YYYY-MM-DD or YYYY-MM)');
+  }
+
+  // Temporal consistency check
+  if (
+    entity.start &&
+    typeof entity.start === 'string' &&
+    entity.end !== null &&
+    entity.end !== undefined &&
+    typeof entity.end === 'string'
+  ) {
+    if (!isValidDate(entity.end)) {
+      errors.push('Field "end" must be a valid ISO date (YYYY-MM-DD or YYYY-MM)');
+    } else if (!isTemporallyConsistent(entity.start, entity.end)) {
+      errors.push('Temporal inconsistency: start date must be less than or equal to end date');
+    }
+  }
+
+  return { valid: errors.length === 0, errors };
+}
+
+export function validateSkill(entity: Record<string, unknown>): ValidationResult {
+  const errors = validateCommonFields(entity);
+
+  if (!entity.name || typeof entity.name !== 'string') {
+    errors.push('Missing required field: name');
+  }
+
+  if (!entity.category) {
+    errors.push('Missing required field: category');
+  } else if (typeof entity.category !== 'string') {
+    errors.push('Field "category" must be a string');
+  } else if (!VALID_SKILL_CATEGORIES.includes(entity.category as SkillCategory)) {
+    errors.push(`Field "category" must be one of: ${VALID_SKILL_CATEGORIES.join(', ')}`);
+  }
+
+  if (!entity.level) {
+    errors.push('Missing required field: level');
+  } else if (typeof entity.level !== 'string') {
+    errors.push('Field "level" must be a string');
+  } else if (!VALID_SKILL_LEVELS.includes(entity.level as SkillLevel)) {
+    errors.push(`Field "level" must be one of: ${VALID_SKILL_LEVELS.join(', ')}`);
+  }
+
+  return { valid: errors.length === 0, errors };
+}
+
+export function validateOrganization(entity: Record<string, unknown>): ValidationResult {
+  const errors = validateCommonFields(entity);
+
+  if (!entity.name || typeof entity.name !== 'string') {
+    errors.push('Missing required field: name');
+  }
+
+  if (!entity.industry || typeof entity.industry !== 'string') {
+    errors.push('Missing required field: industry');
+  }
+
+  return { valid: errors.length === 0, errors };
+}
+
+export function validateProject(entity: Record<string, unknown>): ValidationResult {
+  const errors = validateCommonFields(entity);
+
+  if (!entity.name || typeof entity.name !== 'string') {
+    errors.push('Missing required field: name');
+  }
+
+  if (!entity.organization || typeof entity.organization !== 'string') {
+    errors.push('Missing required field: organization');
+  }
+
+  if (!entity.start) {
+    errors.push('Missing required field: start');
+  } else if (typeof entity.start !== 'string') {
+    errors.push('Field "start" must be a string');
+  } else if (!isValidDate(entity.start)) {
+    errors.push('Field "start" must be a valid ISO date (YYYY-MM-DD or YYYY-MM)');
+  }
+
+  // Temporal consistency check
+  if (
+    entity.start &&
+    typeof entity.start === 'string' &&
+    entity.end !== null &&
+    entity.end !== undefined &&
+    typeof entity.end === 'string'
+  ) {
+    if (!isValidDate(entity.end)) {
+      errors.push('Field "end" must be a valid ISO date (YYYY-MM-DD or YYYY-MM)');
+    } else if (!isTemporallyConsistent(entity.start, entity.end)) {
+      errors.push('Temporal inconsistency: start date must be less than or equal to end date');
+    }
+  }
+
+  return { valid: errors.length === 0, errors };
+}
+
+export function validateCertification(entity: Record<string, unknown>): ValidationResult {
+  const errors = validateCommonFields(entity);
+
+  if (!entity.name || typeof entity.name !== 'string') {
+    errors.push('Missing required field: name');
+  }
+
+  if (!entity.issuer || typeof entity.issuer !== 'string') {
+    errors.push('Missing required field: issuer');
+  }
+
+  if (!entity.date) {
+    errors.push('Missing required field: date');
+  } else if (typeof entity.date !== 'string') {
+    errors.push('Field "date" must be a string');
+  } else if (!isValidDate(entity.date)) {
+    errors.push('Field "date" must be a valid ISO date (YYYY-MM-DD or YYYY-MM)');
+  }
+
+  if (!entity.person || typeof entity.person !== 'string') {
+    errors.push('Missing required field: person');
+  }
+
+  return { valid: errors.length === 0, errors };
+}
+
+export function validateTandem(entity: Record<string, unknown>): ValidationResult {
+  const errors = validateCommonFields(entity);
+
+  if (!entity.partners) {
+    errors.push('Missing required field: partners');
+  } else if (!Array.isArray(entity.partners)) {
+    errors.push('Field "partners" must be an array');
+  } else if (entity.partners.length !== 2) {
+    errors.push('Field "partners" must contain exactly 2 entries');
+  } else if (
+    typeof entity.partners[0] !== 'string' ||
+    typeof entity.partners[1] !== 'string'
+  ) {
+    errors.push('Field "partners" must contain exactly 2 strings');
+  }
+
+  if (!entity.sharedVision || typeof entity.sharedVision !== 'string') {
+    errors.push('Missing required field: sharedVision');
+  }
+
+  if (!entity.complementarySkills || typeof entity.complementarySkills !== 'string') {
+    errors.push('Missing required field: complementarySkills');
+  }
+
+  if (!entity.collaborationModel || typeof entity.collaborationModel !== 'string') {
+    errors.push('Missing required field: collaborationModel');
+  }
+
+  return { valid: errors.length === 0, errors };
+}
+
+// --- Main Dispatch Function ---
+
+/**
+ * Validates an entity by dispatching to the appropriate validator based on the `type` field.
+ * Returns a ValidationResult with descriptive errors if validation fails.
+ */
+export function validateEntity(entity: unknown): ValidationResult {
+  if (entity === null || entity === undefined) {
+    return { valid: false, errors: ['Entity must not be null or undefined'] };
+  }
+
+  if (typeof entity !== 'object') {
+    return { valid: false, errors: ['Entity must be an object'] };
+  }
+
+  const obj = entity as Record<string, unknown>;
+
+  if (!obj.type || typeof obj.type !== 'string') {
+    return { valid: false, errors: ['Missing required field: type'] };
+  }
+
+  switch (obj.type) {
+    case 'person':
+      return validatePerson(obj);
+    case 'experience':
+      return validateExperience(obj);
+    case 'skill':
+      return validateSkill(obj);
+    case 'organization':
+      return validateOrganization(obj);
+    case 'project':
+      return validateProject(obj);
+    case 'certification':
+      return validateCertification(obj);
+    case 'tandem':
+      return validateTandem(obj);
+    default:
+      return {
+        valid: false,
+        errors: [`Field "type" must be one of: ${VALID_ENTITY_TYPES.join(', ')}`],
+      };
+  }
+}