diff --git a/apps/calendar/apps/web/src/lib/components/calendar/UnifiedBar.svelte b/apps/calendar/apps/web/src/lib/components/calendar/UnifiedBar.svelte
index c15708973..1c90120fb 100644
--- a/apps/calendar/apps/web/src/lib/components/calendar/UnifiedBar.svelte
+++ b/apps/calendar/apps/web/src/lib/components/calendar/UnifiedBar.svelte
@@ -1,7 +1,7 @@
 <script lang="ts">
 	import type { Snippet } from 'svelte';
 	import { QuickInputBar } from '@manacore/shared-ui';
-	import type { QuickInputItem } from '@manacore/shared-ui';
+	import type { QuickInputItem, CreatePreview } from '@manacore/shared-ui';
 	import { unifiedBarStore } from '$lib/stores/unified-bar.svelte';
 	import DateStrip from './DateStrip.svelte';
 	import TagStrip from './TagStrip.svelte';
@@ -14,6 +14,8 @@
 	interface Props {
 		onSearch: (query: string) => Promise<QuickInputItem[]>;
 		onSelect: (item: QuickInputItem) => void;
+		onParseCreate?: (query: string) => CreatePreview | null;
+		onCreate?: (query: string) => Promise<void>;
 		onSearchChange?: (query: string, results: QuickInputItem[]) => void;
 		placeholder?: string;
 		emptyText?: string;
@@ -39,6 +41,8 @@
 	let {
 		onSearch,
 		onSelect,
+		onParseCreate,
+		onCreate,
 		onSearchChange,
 		placeholder = 'Neuer Termin oder suchen...',
 		emptyText = 'Keine Termine gefunden',
@@ -138,6 +142,8 @@
 		<QuickInputBar
 			{onSearch}
 			{onSelect}
+			{onParseCreate}
+			{onCreate}
 			{onSearchChange}
 			{placeholder}
 			{emptyText}
@@ -145,6 +151,7 @@
 			{createText}
 			{appIcon}
 			{locale}
+			deferSearch={true}
 			bottomOffset="0px"
 			hasFabRight={showCalendarLayers}
 			{defaultOptions}
diff --git a/apps/calendar/apps/web/src/lib/utils/event-parser.test.ts b/apps/calendar/apps/web/src/lib/utils/event-parser.test.ts
new file mode 100644
index 000000000..dcb0a9b9c
--- /dev/null
+++ b/apps/calendar/apps/web/src/lib/utils/event-parser.test.ts
@@ -0,0 +1,205 @@
+import { describe, it, expect } from 'vitest';
+import { parseEventInput, resolveEventIds, formatParsedEventPreview } from './event-parser';
+
+describe('parseEventInput', () => {
+	it('should parse a simple title', () => {
+		const result = parseEventInput('Meeting');
+		expect(result.title).toBe('Meeting');
+		expect(result.startDate).toBeUndefined();
+		expect(result.duration).toBeUndefined();
+		expect(result.tagNames).toEqual([]);
+	});
+
+	it('should parse date and time', () => {
+		const result = parseEventInput('Meeting morgen 14 Uhr');
+		expect(result.title).toBe('Meeting');
+		expect(result.startDate).toBeDefined();
+		expect(result.startDate!.getHours()).toBe(14);
+		expect(result.startDate!.getMinutes()).toBe(0);
+	});
+
+	it('should parse duration in hours', () => {
+		const result = parseEventInput('Meeting 2h');
+		expect(result.duration).toBe(120);
+		expect(result.title).toBe('Meeting');
+	});
+
+	it('should parse duration in minutes', () => {
+		const result = parseEventInput('Standup 30min');
+		expect(result.duration).toBe(30);
+	});
+
+	it('should parse combined duration 2h30m', () => {
+		const result = parseEventInput('Workshop 2h30m');
+		expect(result.duration).toBe(150);
+	});
+
+	it('should parse duration in Stunden', () => {
+		const result = parseEventInput('Konferenz 3 Stunden');
+		expect(result.duration).toBe(180);
+	});
+
+	it('should calculate endDate from startDate + duration', () => {
+		const result = parseEventInput('Meeting morgen 10 Uhr 2h');
+		expect(result.startDate).toBeDefined();
+		expect(result.endDate).toBeDefined();
+		const diffMs = result.endDate!.getTime() - result.startDate!.getTime();
+		expect(diffMs).toBe(120 * 60_000); // 2 hours
+	});
+
+	it('should default to 1h duration when no duration specified', () => {
+		const result = parseEventInput('Meeting morgen 10 Uhr');
+		expect(result.startDate).toBeDefined();
+		expect(result.endDate).toBeDefined();
+		const diffMs = result.endDate!.getTime() - result.startDate!.getTime();
+		expect(diffMs).toBe(60 * 60_000); // 1 hour default
+	});
+
+	it('should parse all-day events', () => {
+		const result = parseEventInput('Ganztägig Urlaub morgen');
+		expect(result.isAllDay).toBe(true);
+		expect(result.title).toBe('Urlaub');
+		expect(result.startDate).toBeDefined();
+	});
+
+	it('should parse @calendar reference', () => {
+		const result = parseEventInput('Meeting @Arbeit');
+		expect(result.calendarName).toBe('Arbeit');
+		expect(result.title).not.toContain('@Arbeit');
+	});
+
+	it('should parse #tags', () => {
+		const result = parseEventInput('Meeting #wichtig #team');
+		expect(result.tagNames).toEqual(['wichtig', 'team']);
+		expect(result.title).not.toContain('#');
+	});
+
+	it('should parse complex input with all fields', () => {
+		const result = parseEventInput('Teammeeting morgen 14 Uhr 1h @Arbeit #wichtig');
+		expect(result.title).toBe('Teammeeting');
+		expect(result.startDate).toBeDefined();
+		expect(result.startDate!.getHours()).toBe(14);
+		expect(result.duration).toBe(60);
+		expect(result.calendarName).toBe('Arbeit');
+		expect(result.tagNames).toEqual(['wichtig']);
+	});
+
+	it('should parse time range "14-16 Uhr"', () => {
+		const result = parseEventInput('Meeting morgen 14-16 Uhr');
+		expect(result.title).toBe('Meeting');
+		expect(result.startDate).toBeDefined();
+		expect(result.startDate!.getHours()).toBe(14);
+		expect(result.endDate).toBeDefined();
+		expect(result.endDate!.getHours()).toBe(16);
+	});
+
+	it('should parse time range "10:00-11:30"', () => {
+		const result = parseEventInput('Standup 10:00-11:30');
+		expect(result.startDate).toBeDefined();
+		expect(result.startDate!.getHours()).toBe(10);
+		expect(result.startDate!.getMinutes()).toBe(0);
+		expect(result.endDate).toBeDefined();
+		expect(result.endDate!.getHours()).toBe(11);
+		expect(result.endDate!.getMinutes()).toBe(30);
+	});
+
+	it('should parse time range with en-dash "9–17 Uhr"', () => {
+		const result = parseEventInput('Arbeitstag 9–17 Uhr');
+		expect(result.startDate!.getHours()).toBe(9);
+		expect(result.endDate!.getHours()).toBe(17);
+	});
+
+	it('should handle empty input', () => {
+		const result = parseEventInput('');
+		expect(result.title).toBe('');
+		expect(result.tagNames).toEqual([]);
+	});
+
+	it('should parse time-only input (defaults to today)', () => {
+		const result = parseEventInput('Lunch 12 Uhr');
+		expect(result.startDate).toBeDefined();
+		expect(result.startDate!.getHours()).toBe(12);
+	});
+});
+
+describe('resolveEventIds', () => {
+	const calendars = [
+		{ id: 'cal-1', name: 'Arbeit' },
+		{ id: 'cal-2', name: 'Privat' },
+	];
+
+	const tags = [
+		{ id: 'tag-1', name: 'Wichtig' },
+		{ id: 'tag-2', name: 'Team' },
+	];
+
+	it('should resolve calendar name to ID (case-insensitive)', () => {
+		const parsed = parseEventInput('Meeting @arbeit');
+		const resolved = resolveEventIds(parsed, calendars, tags);
+		expect(resolved.calendarId).toBe('cal-1');
+	});
+
+	it('should resolve tag names to IDs (case-insensitive)', () => {
+		const parsed = parseEventInput('Meeting #team');
+		const resolved = resolveEventIds(parsed, calendars, tags);
+		expect(resolved.tagIds).toEqual(['tag-2']);
+	});
+
+	it('should use default calendar when no calendar specified', () => {
+		const parsed = parseEventInput('Meeting morgen');
+		const resolved = resolveEventIds(parsed, calendars, tags, 'cal-1');
+		expect(resolved.calendarId).toBe('cal-1');
+	});
+
+	it('should skip unknown calendar', () => {
+		const parsed = parseEventInput('Meeting @Unbekannt');
+		const resolved = resolveEventIds(parsed, calendars, tags);
+		expect(resolved.calendarId).toBeUndefined();
+	});
+
+	it('should produce ISO date strings', () => {
+		const parsed = parseEventInput('Meeting morgen 14 Uhr');
+		const resolved = resolveEventIds(parsed, calendars, tags);
+		expect(resolved.startTime).toBeDefined();
+		expect(resolved.endTime).toBeDefined();
+		// Verify it's a valid ISO string
+		expect(new Date(resolved.startTime!).toISOString()).toBe(resolved.startTime);
+	});
+});
+
+describe('formatParsedEventPreview', () => {
+	it('should format duration', () => {
+		const parsed = parseEventInput('Meeting 2h');
+		const preview = formatParsedEventPreview(parsed);
+		expect(preview).toContain('2h');
+	});
+
+	it('should format calendar', () => {
+		const parsed = parseEventInput('Meeting @Arbeit');
+		const preview = formatParsedEventPreview(parsed);
+		expect(preview).toContain('Arbeit');
+	});
+
+	it('should format tags', () => {
+		const parsed = parseEventInput('Meeting #team');
+		const preview = formatParsedEventPreview(parsed);
+		expect(preview).toContain('team');
+	});
+
+	it('should format all-day events', () => {
+		const parsed = parseEventInput('Ganztägig Urlaub morgen');
+		const preview = formatParsedEventPreview(parsed);
+		expect(preview).toContain('ganztägig');
+	});
+
+	it('should return empty string for title-only input', () => {
+		const parsed = parseEventInput('Einfaches Meeting');
+		expect(formatParsedEventPreview(parsed)).toBe('');
+	});
+
+	it('should join parts with separator', () => {
+		const parsed = parseEventInput('Meeting morgen 14 Uhr 1h @Arbeit');
+		const preview = formatParsedEventPreview(parsed);
+		expect(preview).toContain(' · ');
+	});
+});
diff --git a/apps/calendar/apps/web/src/lib/utils/event-parser.ts b/apps/calendar/apps/web/src/lib/utils/event-parser.ts
new file mode 100644
index 000000000..ff2ae55f9
--- /dev/null
+++ b/apps/calendar/apps/web/src/lib/utils/event-parser.ts
@@ -0,0 +1,404 @@
+/**
+ * Event Parser for Calendar App
+ *
+ * Extends the base parser with event-specific patterns:
+ * - Duration: 1h, 30min, 2h30m, 1 Stunde
+ * - Location: in Berlin, im Büro
+ * - Calendar: @CalendarName
+ *
+ * Examples:
+ * - "Meeting morgen 14 Uhr 1h @Arbeit #wichtig"
+ * - "Arzttermin 15.12. 10:00 30min in Praxis Dr. Müller"
+ * - "Mittagessen heute 12 Uhr"
+ * - "Ganztägig Urlaub nächste Woche"
+ */
+
+import {
+	parseBaseInput,
+	extractAtReference,
+	combineDateAndTime,
+	formatDatePreview,
+	formatTimePreview,
+	type ParserLocale,
+} from '@manacore/shared-utils';
+import { addHours } from 'date-fns';
+
+export interface ParsedEvent {
+	title: string;
+	startDate?: Date;
+	endDate?: Date;
+	duration?: number; // in minutes
+	isAllDay?: boolean;
+	calendarName?: string;
+	location?: string;
+	tagNames: string[];
+}
+
+interface Calendar {
+	id: string;
+	name: string;
+}
+
+interface Tag {
+	id: string;
+	name: string;
+}
+
+export interface ParsedEventWithIds {
+	title: string;
+	startTime?: string;
+	endTime?: string;
+	isAllDay?: boolean;
+	calendarId?: string;
+	location?: string;
+	tagIds: string[];
+}
+
+// ============================================================================
+// Time Range Extraction (14-16 Uhr, 10:00-11:30)
+// ============================================================================
+
+// "14-16 Uhr", "14:00-16:00", "10-11:30"
+const TIME_RANGE_PATTERN =
+	/\b(?:um\s*)?(\d{1,2})(?::(\d{2}))?\s*[-–]\s*(\d{1,2})(?::(\d{2}))?\s*(?:uhr)?\b/i;
+
+function extractTimeRange(text: string): {
+	startTime?: { hours: number; minutes: number };
+	endTime?: { hours: number; minutes: number };
+	remaining: string;
+} {
+	const match = text.match(TIME_RANGE_PATTERN);
+	if (match) {
+		const startHours = parseInt(match[1]);
+		const startMinutes = match[2] ? parseInt(match[2]) : 0;
+		const endHours = parseInt(match[3]);
+		const endMinutes = match[4] ? parseInt(match[4]) : 0;
+
+		if (
+			startHours >= 0 &&
+			startHours <= 23 &&
+			endHours >= 0 &&
+			endHours <= 23 &&
+			startMinutes >= 0 &&
+			startMinutes <= 59 &&
+			endMinutes >= 0 &&
+			endMinutes <= 59
+		) {
+			return {
+				startTime: { hours: startHours, minutes: startMinutes },
+				endTime: { hours: endHours, minutes: endMinutes },
+				remaining: text.replace(TIME_RANGE_PATTERN, '').trim(),
+			};
+		}
+	}
+	return { remaining: text };
+}
+
+// ============================================================================
+// Duration Extraction
+// ============================================================================
+
+// Locale-specific "hours" words (Stunden, hours, heures, horas, ore)
+const HOURS_WORDS: Record<ParserLocale, string> = {
+	de: 'stunde[n]?',
+	en: 'hours?',
+	fr: 'heures?',
+	es: 'horas?',
+	it: 'ore',
+};
+
+function getDurationPatterns(
+	locale: ParserLocale
+): { pattern: RegExp; getMinutes: (match: RegExpMatchArray) => number }[] {
+	const hoursWord = HOURS_WORDS[locale];
+	return [
+		// 2h30m, 2h 30m, 1h30min
+		{
+			pattern: /\b(\d+)\s*h\s*(\d+)\s*(?:m(?:in)?)\b/i,
+			getMinutes: (m) => parseInt(m[1]) * 60 + parseInt(m[2]),
+		},
+		// 1h, 2h (hours only)
+		{ pattern: /\b(\d+)\s*h\b/i, getMinutes: (m) => parseInt(m[1]) * 60 },
+		// 30min, 45 min, 90 Minuten/minutes/etc.
+		{
+			pattern: /\b(\d+)\s*(?:min(?:uten?|utes?)?)\b/i,
+			getMinutes: (m) => parseInt(m[1]),
+		},
+		// Locale-specific full word: 1 Stunde, 2 hours, 3 heures, etc.
+		{
+			pattern: new RegExp(`\\b(\\d+)\\s*${hoursWord}\\b`, 'i'),
+			getMinutes: (m) => parseInt(m[1]) * 60,
+		},
+	];
+}
+
+function extractDuration(
+	text: string,
+	locale: ParserLocale = 'de'
+): { duration?: number; remaining: string } {
+	for (const { pattern, getMinutes } of getDurationPatterns(locale)) {
+		const match = text.match(pattern);
+		if (match) {
+			return {
+				duration: getMinutes(match),
+				remaining: text.replace(pattern, '').trim(),
+			};
+		}
+	}
+	return { duration: undefined, remaining: text };
+}
+
+// ============================================================================
+// Location Extraction
+// ============================================================================
+
+// Location extraction - runs on the title AFTER date/time extraction has already
+// removed date keywords like "in 3 Tagen", "in einer halben Stunde" etc.
+// "in Berlin", "im Büro", "bei Dr. Müller", "am Bahnhof"
+const LOCATION_PATTERN = /\b(?:in|im|bei|am)\s+(.+?)(?=\s+(?:@|#)|$)/i;
+
+// Patterns that look like dates/times but not locations (multilingual)
+const NOT_LOCATION_PATTERN =
+	/^\d+\s*(tage?n?|wochen?|stunde[n]?|minute[n]?|hours?|minutes?|heures?|horas?|ore|h|min)$/i;
+
+function extractLocation(text: string): { location?: string; remaining: string } {
+	const match = text.match(LOCATION_PATTERN);
+	if (match) {
+		const location = match[1].trim();
+
+		// Skip if it looks like a leftover time/date expression
+		if (NOT_LOCATION_PATTERN.test(location)) {
+			return { location: undefined, remaining: text };
+		}
+
+		// Skip if starts with a number (likely a leftover numeric expression)
+		if (/^\d+\s/.test(location) && location.length < 5) {
+			return { location: undefined, remaining: text };
+		}
+
+		if (location.length >= 2) {
+			return {
+				location,
+				remaining: text.replace(LOCATION_PATTERN, '').trim(),
+			};
+		}
+	}
+	return { location: undefined, remaining: text };
+}
+
+// ============================================================================
+// All-Day Detection
+// ============================================================================
+
+const ALL_DAY_PATTERNS: Record<ParserLocale, RegExp[]> = {
+	de: [/\bganzt[aä]gig\b/i, /\bganzer\s+tag\b/i],
+	en: [/\ball[- ]?day\b/i, /\bwhole\s+day\b/i],
+	fr: [/\btoute\s+la\s+journ[eé]e\b/i, /\bjour\s+entier\b/i],
+	es: [/\btodo\s+el\s+d[ií]a\b/i, /\bd[ií]a\s+completo\b/i],
+	it: [/\btutto\s+il\s+giorno\b/i, /\bgiornata\s+intera\b/i],
+};
+
+function getAllDayPatterns(locale: ParserLocale): RegExp[] {
+	return ALL_DAY_PATTERNS[locale];
+}
+
+function extractAllDay(
+	text: string,
+	locale: ParserLocale = 'de'
+): { isAllDay: boolean; remaining: string } {
+	for (const pattern of getAllDayPatterns(locale)) {
+		if (pattern.test(text)) {
+			return {
+				isAllDay: true,
+				remaining: text.replace(pattern, '').trim(),
+			};
+		}
+	}
+	return { isAllDay: false, remaining: text };
+}
+
+// ============================================================================
+// Main Parser
+// ============================================================================
+
+/**
+ * Parse natural language event input
+ *
+ * Examples:
+ * - "Meeting morgen 14 Uhr 1h @Arbeit #wichtig"
+ * - "Arzttermin 15.12. 10:00 30min"
+ * - "Ganztägig Urlaub morgen"
+ */
+export function parseEventInput(input: string, locale: ParserLocale = 'de'): ParsedEvent {
+	let text = input.trim();
+
+	// Extract all-day flag
+	const allDayResult = extractAllDay(text, locale);
+	text = allDayResult.remaining;
+	const isAllDay = allDayResult.isAllDay;
+
+	// Extract time range first (14-16 Uhr, 10:00-11:30)
+	const timeRangeResult = extractTimeRange(text);
+	text = timeRangeResult.remaining;
+
+	// Extract duration (before base parser, since "30min" could conflict with time)
+	const durationResult = extractDuration(text, locale);
+	text = durationResult.remaining;
+	const duration = durationResult.duration;
+
+	// Extract calendar (@CalendarName)
+	const calendarResult = extractAtReference(text);
+	text = calendarResult.remaining;
+	const calendarName = calendarResult.value;
+
+	// Use base parser for common patterns (date, time, tags)
+	const base = parseBaseInput(text, locale);
+
+	// Try to extract location from the remaining title
+	const locationResult = extractLocation(base.title);
+	const title = locationResult.location ? locationResult.remaining : base.title;
+	const location = locationResult.location;
+
+	// Build start/end dates
+	let startDate: Date | undefined;
+	let endDate: Date | undefined;
+
+	if (timeRangeResult.startTime && timeRangeResult.endTime) {
+		// Time range provided: use it directly
+		const dateForRange = base.date || new Date();
+		startDate = combineDateAndTime(dateForRange, timeRangeResult.startTime);
+		endDate = combineDateAndTime(dateForRange, timeRangeResult.endTime);
+	} else {
+		// Single time or no time
+		startDate = combineDateAndTime(base.date, isAllDay ? undefined : base.time);
+
+		if (startDate) {
+			if (isAllDay) {
+				endDate = new Date(startDate);
+				endDate.setHours(23, 59, 59);
+			} else if (duration) {
+				endDate = new Date(startDate.getTime() + duration * 60_000);
+			} else {
+				// Default: 1 hour
+				endDate = addHours(startDate, 1);
+			}
+		}
+	}
+
+	return {
+		title,
+		startDate,
+		endDate,
+		duration,
+		isAllDay: isAllDay || undefined,
+		calendarName,
+		location,
+		tagNames: base.tagNames,
+	};
+}
+
+// ============================================================================
+// ID Resolution
+// ============================================================================
+
+/**
+ * Resolve calendar and tag names to IDs
+ */
+export function resolveEventIds(
+	parsed: ParsedEvent,
+	calendars: Calendar[],
+	tags: Tag[],
+	defaultCalendarId?: string
+): ParsedEventWithIds {
+	let calendarId: string | undefined;
+	const tagIds: string[] = [];
+
+	// Find calendar by name (case-insensitive)
+	if (parsed.calendarName) {
+		const calendar = calendars.find(
+			(c) => c.name.toLowerCase() === parsed.calendarName!.toLowerCase()
+		);
+		if (calendar) {
+			calendarId = calendar.id;
+		}
+	}
+
+	// Fallback to default calendar
+	if (!calendarId && defaultCalendarId) {
+		calendarId = defaultCalendarId;
+	}
+
+	// Find tags by name (case-insensitive)
+	for (const tagName of parsed.tagNames) {
+		const tag = tags.find((t) => t.name.toLowerCase() === tagName.toLowerCase());
+		if (tag) {
+			tagIds.push(tag.id);
+		}
+	}
+
+	return {
+		title: parsed.title,
+		startTime: parsed.startDate?.toISOString(),
+		endTime: parsed.endDate?.toISOString(),
+		isAllDay: parsed.isAllDay,
+		calendarId,
+		location: parsed.location,
+		tagIds,
+	};
+}
+
+// ============================================================================
+// Preview Formatting
+// ============================================================================
+
+// Locale-specific "all-day" label for preview display
+const ALL_DAY_LABEL: Record<ParserLocale, string> = {
+	de: 'ganztägig',
+	en: 'all-day',
+	fr: 'toute la journée',
+	es: 'todo el día',
+	it: 'tutto il giorno',
+};
+
+/**
+ * Format parsed event for preview display
+ */
+export function formatParsedEventPreview(parsed: ParsedEvent, locale: ParserLocale = 'de'): string {
+	const parts: string[] = [];
+
+	if (parsed.isAllDay && parsed.startDate) {
+		parts.push(`📅 ${formatDatePreview(parsed.startDate, locale)} (${ALL_DAY_LABEL[locale]})`);
+	} else if (parsed.startDate) {
+		let dateStr = `📅 ${formatDatePreview(parsed.startDate, locale)}`;
+		if (parsed.startDate.getHours() !== 0 || parsed.startDate.getMinutes() !== 0) {
+			dateStr += ` ${formatTimePreview({
+				hours: parsed.startDate.getHours(),
+				minutes: parsed.startDate.getMinutes(),
+			})}`;
+		}
+		parts.push(dateStr);
+	}
+
+	if (parsed.duration) {
+		const hours = Math.floor(parsed.duration / 60);
+		const mins = parsed.duration % 60;
+		let durationStr = '';
+		if (hours > 0) durationStr += `${hours}h`;
+		if (mins > 0) durationStr += `${mins}min`;
+		parts.push(`⏱️ ${durationStr}`);
+	}
+
+	if (parsed.location) {
+		parts.push(`📍 ${parsed.location}`);
+	}
+
+	if (parsed.calendarName) {
+		parts.push(`📆 ${parsed.calendarName}`);
+	}
+
+	if (parsed.tagNames.length > 0) {
+		parts.push(`🏷️ ${parsed.tagNames.join(', ')}`);
+	}
+
+	return parts.join(' · ');
+}
diff --git a/apps/mukke/apps/web/src/lib/utils/song-parser.test.ts b/apps/mukke/apps/web/src/lib/utils/song-parser.test.ts
new file mode 100644
index 000000000..8048f3823
--- /dev/null
+++ b/apps/mukke/apps/web/src/lib/utils/song-parser.test.ts
@@ -0,0 +1,104 @@
+import { describe, it, expect } from 'vitest';
+import { parseSongInput, formatParsedSongPreview } from './song-parser';
+
+describe('parseSongInput', () => {
+	it('should parse a simple title', () => {
+		const result = parseSongInput('My Song');
+		expect(result.title).toBe('My Song');
+		expect(result.artist).toBeUndefined();
+		expect(result.tagNames).toEqual([]);
+	});
+
+	it('should parse "Artist - Title" format', () => {
+		const result = parseSongInput('Queen - Bohemian Rhapsody');
+		expect(result.artist).toBe('Queen');
+		expect(result.title).toBe('Bohemian Rhapsody');
+	});
+
+	it('should parse with en-dash separator', () => {
+		const result = parseSongInput('Beatles – Hey Jude');
+		expect(result.artist).toBe('Beatles');
+		expect(result.title).toBe('Hey Jude');
+	});
+
+	it('should parse genre tags', () => {
+		const result = parseSongInput('Song #rock #classic');
+		expect(result.genre).toBe('rock');
+		expect(result.tagNames).toEqual(['rock', 'classic']);
+	});
+
+	it('should parse BPM', () => {
+		const result = parseSongInput('Beat 120bpm');
+		expect(result.bpm).toBe(120);
+		expect(result.title).toBe('Beat');
+	});
+
+	it('should parse year', () => {
+		const result = parseSongInput('Song 1975');
+		expect(result.year).toBe(1975);
+	});
+
+	it('should detect playlist creation', () => {
+		const result = parseSongInput('Neue Playlist Workout #electronic');
+		expect(result.isPlaylist).toBe(true);
+		expect(result.title).toBe('Workout');
+		expect(result.genre).toBe('electronic');
+	});
+
+	it('should detect project creation', () => {
+		const result = parseSongInput('Neues Projekt Demo 90bpm');
+		expect(result.isProject).toBe(true);
+		expect(result.title).toBe('Demo');
+		expect(result.bpm).toBe(90);
+	});
+
+	it('should parse complex input', () => {
+		const result = parseSongInput('Daft Punk - Get Lucky 2013 #electronic #disco');
+		expect(result.artist).toBe('Daft Punk');
+		expect(result.title).toBe('Get Lucky');
+		expect(result.year).toBe(2013);
+		expect(result.genre).toBe('electronic');
+	});
+
+	it('should handle empty input', () => {
+		const result = parseSongInput('');
+		expect(result.title).toBe('');
+		expect(result.tagNames).toEqual([]);
+	});
+
+	it('should ignore invalid BPM', () => {
+		const result = parseSongInput('Track 5bpm'); // too low
+		expect(result.bpm).toBeUndefined();
+	});
+});
+
+describe('formatParsedSongPreview', () => {
+	it('should format artist', () => {
+		const parsed = parseSongInput('Queen - Song');
+		const preview = formatParsedSongPreview(parsed);
+		expect(preview).toContain('Queen');
+	});
+
+	it('should format genre', () => {
+		const parsed = parseSongInput('Song #rock');
+		const preview = formatParsedSongPreview(parsed);
+		expect(preview).toContain('rock');
+	});
+
+	it('should format BPM', () => {
+		const parsed = parseSongInput('Beat 120bpm');
+		const preview = formatParsedSongPreview(parsed);
+		expect(preview).toContain('120 BPM');
+	});
+
+	it('should format playlist type', () => {
+		const parsed = parseSongInput('Neue Playlist Workout');
+		const preview = formatParsedSongPreview(parsed);
+		expect(preview).toContain('Neue Playlist');
+	});
+
+	it('should return empty for simple title', () => {
+		const parsed = parseSongInput('Simple Song');
+		expect(formatParsedSongPreview(parsed)).toBe('');
+	});
+});
diff --git a/apps/mukke/apps/web/src/lib/utils/song-parser.ts b/apps/mukke/apps/web/src/lib/utils/song-parser.ts
new file mode 100644
index 000000000..84c83e282
--- /dev/null
+++ b/apps/mukke/apps/web/src/lib/utils/song-parser.ts
@@ -0,0 +1,193 @@
+/**
+ * Song/Project Parser for Mukke App
+ *
+ * Parses natural language input into song metadata or project creation.
+ *
+ * Patterns:
+ * - "Artist - Title" format for songs
+ * - #genre tags
+ * - BPM number (e.g., 120bpm)
+ * - Year (e.g., 2024)
+ *
+ * Examples:
+ * - "Queen - Bohemian Rhapsody #rock"
+ * - "Neue Playlist Workout #electronic #techno"
+ * - "Projekt Demo Song 120bpm"
+ */
+
+import { extractTags, type ParserLocale } from '@manacore/shared-utils';
+
+export interface ParsedSong {
+	title: string;
+	artist?: string;
+	album?: string;
+	genre?: string;
+	bpm?: number;
+	year?: number;
+	tagNames: string[];
+	isPlaylist?: boolean;
+	isProject?: boolean;
+}
+
+// BPM pattern: 120bpm, 120 BPM
+const BPM_PATTERN = /\b(\d{2,3})\s*bpm\b/i;
+
+// Year pattern: standalone 4-digit year (1900-2099)
+const YEAR_PATTERN = /\b((?:19|20)\d{2})\b/;
+
+// Playlist creation keywords per locale
+const PLAYLIST_PATTERNS_BY_LOCALE: Record<ParserLocale, RegExp[]> = {
+	de: [/\bneue?\s*playlist\b/i, /\bplaylist\b/i],
+	en: [/\bnew\s+playlist\b/i, /\bplaylist\b/i],
+	fr: [/\bnouvelle\s+playlist\b/i, /\bplaylist\b/i],
+	es: [/\bnueva\s+playlist\b/i, /\bplaylist\b/i],
+	it: [/\bnuova\s+playlist\b/i, /\bplaylist\b/i],
+};
+
+// Project creation keywords per locale
+const PROJECT_PATTERNS_BY_LOCALE: Record<ParserLocale, RegExp[]> = {
+	de: [/\bneue?s?\s*projekt\b/i, /\bprojekt\b/i],
+	en: [/\bnew\s+project\b/i, /\bproject\b/i],
+	fr: [/\bnouveau\s+projet\b/i, /\bprojet\b/i],
+	es: [/\bnuevo\s+proyecto\b/i, /\bproyecto\b/i],
+	it: [/\bnuovo\s+progetto\b/i, /\bprogetto\b/i],
+};
+
+// "Artist - Title" separator
+const ARTIST_TITLE_SEPARATOR = /\s+[-–—]\s+/;
+
+function extractBpm(text: string): { bpm?: number; remaining: string } {
+	const match = text.match(BPM_PATTERN);
+	if (match) {
+		const bpm = parseInt(match[1]);
+		if (bpm >= 20 && bpm <= 300) {
+			return { bpm, remaining: text.replace(BPM_PATTERN, '').trim() };
+		}
+	}
+	return { bpm: undefined, remaining: text };
+}
+
+function extractYear(text: string): { year?: number; remaining: string } {
+	const match = text.match(YEAR_PATTERN);
+	if (match) {
+		return {
+			year: parseInt(match[1]),
+			remaining: text.replace(YEAR_PATTERN, '').trim(),
+		};
+	}
+	return { year: undefined, remaining: text };
+}
+
+// Preview labels per locale
+const TYPE_LABELS_BY_LOCALE: Record<ParserLocale, { playlist: string; project: string }> = {
+	de: { playlist: 'Neue Playlist', project: 'Neues Projekt' },
+	en: { playlist: 'New Playlist', project: 'New Project' },
+	fr: { playlist: 'Nouvelle Playlist', project: 'Nouveau Projet' },
+	es: { playlist: 'Nueva Playlist', project: 'Nuevo Proyecto' },
+	it: { playlist: 'Nuova Playlist', project: 'Nuovo Progetto' },
+};
+
+function extractTypeKeyword(
+	text: string,
+	locale: ParserLocale = 'de'
+): { type?: 'playlist' | 'project'; remaining: string } {
+	const playlistPatterns = PLAYLIST_PATTERNS_BY_LOCALE[locale];
+	for (const pattern of playlistPatterns) {
+		if (pattern.test(text)) {
+			return { type: 'playlist', remaining: text.replace(pattern, '').trim() };
+		}
+	}
+	const projectPatterns = PROJECT_PATTERNS_BY_LOCALE[locale];
+	for (const pattern of projectPatterns) {
+		if (pattern.test(text)) {
+			return { type: 'project', remaining: text.replace(pattern, '').trim() };
+		}
+	}
+	return { type: undefined, remaining: text };
+}
+
+/**
+ * Parse natural language song/project input
+ */
+export function parseSongInput(input: string, locale: ParserLocale = 'de'): ParsedSong {
+	let text = input.trim();
+
+	// Extract tags first
+	const tagsResult = extractTags(text);
+	text = tagsResult.remaining;
+	const tagNames = tagsResult.value || [];
+
+	// Use first tag as genre hint
+	const genre = tagNames.length > 0 ? tagNames[0] : undefined;
+
+	// Extract type keyword (playlist/project)
+	const typeResult = extractTypeKeyword(text, locale);
+	text = typeResult.remaining;
+
+	// Extract BPM
+	const bpmResult = extractBpm(text);
+	text = bpmResult.remaining;
+
+	// Extract year
+	const yearResult = extractYear(text);
+	text = yearResult.remaining;
+
+	// Try "Artist - Title" format
+	let artist: string | undefined;
+	let title: string;
+
+	if (ARTIST_TITLE_SEPARATOR.test(text)) {
+		const parts = text.split(ARTIST_TITLE_SEPARATOR, 2);
+		artist = parts[0].trim();
+		title = parts[1].trim();
+	} else {
+		title = text.replace(/\s+/g, ' ').trim();
+	}
+
+	return {
+		title,
+		artist,
+		genre,
+		bpm: bpmResult.bpm,
+		year: yearResult.year,
+		tagNames,
+		isPlaylist: typeResult.type === 'playlist',
+		isProject: typeResult.type === 'project',
+	};
+}
+
+/**
+ * Format parsed song for preview display
+ */
+export function formatParsedSongPreview(parsed: ParsedSong, locale: ParserLocale = 'de'): string {
+	const parts: string[] = [];
+
+	const typeLabels = TYPE_LABELS_BY_LOCALE[locale];
+	if (parsed.isPlaylist) {
+		parts.push(`📋 ${typeLabels.playlist}`);
+	} else if (parsed.isProject) {
+		parts.push(`🎛️ ${typeLabels.project}`);
+	}
+
+	if (parsed.artist) {
+		parts.push(`🎤 ${parsed.artist}`);
+	}
+
+	if (parsed.genre) {
+		parts.push(`🎵 ${parsed.genre}`);
+	}
+
+	if (parsed.bpm) {
+		parts.push(`⏱️ ${parsed.bpm} BPM`);
+	}
+
+	if (parsed.year) {
+		parts.push(`📅 ${parsed.year}`);
+	}
+
+	if (parsed.tagNames.length > 1) {
+		parts.push(`🏷️ ${parsed.tagNames.slice(1).join(', ')}`);
+	}
+
+	return parts.join(' · ');
+}
diff --git a/apps/mukke/apps/web/src/routes/(app)/+layout.svelte b/apps/mukke/apps/web/src/routes/(app)/+layout.svelte
index 348208327..9b9f339bb 100644
--- a/apps/mukke/apps/web/src/routes/(app)/+layout.svelte
+++ b/apps/mukke/apps/web/src/routes/(app)/+layout.svelte
@@ -3,7 +3,12 @@
 	import { page } from '$app/stores';
 	import { onMount } from 'svelte';
 	import { PillNavigation, QuickInputBar, DevBuildBadge } from '@manacore/shared-ui';
-	import type { PillNavItem, PillDropdownItem, QuickInputItem } from '@manacore/shared-ui';
+	import type {
+		PillNavItem,
+		PillDropdownItem,
+		QuickInputItem,
+		CreatePreview,
+	} from '@manacore/shared-ui';
 	import {
 		SplitPaneContainer,
 		setSplitPanelContext,
@@ -19,6 +24,10 @@
 	import { theme } from '$lib/stores/theme.svelte';
 	import { authStore } from '$lib/stores/auth.svelte';
 	import { libraryStore } from '$lib/stores/library.svelte';
+	import { playlistStore } from '$lib/stores/playlist.svelte';
+	import { projectStore } from '$lib/stores/project.svelte';
+	import { parseSongInput, formatParsedSongPreview } from '$lib/utils/song-parser';
+	import { SessionExpiredBanner } from '@manacore/shared-auth-ui';
 	import MiniPlayer from '$lib/components/MiniPlayer.svelte';
 	import FullPlayer from '$lib/components/FullPlayer.svelte';
 	import QueuePanel from '$lib/components/QueuePanel.svelte';
@@ -118,6 +127,46 @@
 		goto(`/library?song=${item.id}`);
 	}
 
+	// Quick-Create handlers
+	function handleParseCreate(query: string): CreatePreview | null {
+		if (!query.trim()) return null;
+		const parsed = parseSongInput(query);
+		if (!parsed.title) return null;
+		const preview = formatParsedSongPreview(parsed);
+		if (parsed.isPlaylist) {
+			return {
+				title: `Playlist "${parsed.title}" erstellen`,
+				subtitle: preview || 'Neue Playlist',
+			};
+		}
+		if (parsed.isProject) {
+			return {
+				title: `Projekt "${parsed.title}" erstellen`,
+				subtitle: preview || 'Neues Projekt',
+			};
+		}
+		return {
+			title: `Projekt "${parsed.title}" erstellen`,
+			subtitle: preview || 'Neues Projekt',
+		};
+	}
+
+	async function handleCreate(query: string): Promise<void> {
+		if (!query.trim()) return;
+		const parsed = parseSongInput(query);
+		if (!parsed.title) return;
+
+		if (parsed.isPlaylist) {
+			await playlistStore.createPlaylist(parsed.title);
+			goto('/playlists');
+			return;
+		}
+
+		// Default: create project
+		await projectStore.createProject(parsed.title);
+		goto('/projects');
+	}
+
 	onMount(async () => {
 		await authStore.initialize();
 		if (!authStore.isAuthenticated) {
@@ -175,9 +224,13 @@
 			<QuickInputBar
 				onSearch={handleInputSearch}
 				onSelect={handleInputSelect}
-				placeholder="Song suchen..."
+				onParseCreate={handleParseCreate}
+				onCreate={handleCreate}
+				placeholder="Song suchen oder Projekt erstellen..."
 				emptyText="Keine Songs gefunden"
 				searchingText="Suche..."
+				createText="Erstellen"
+				deferSearch={true}
 				locale="de"
 				appIcon="search"
 				bottomOffset="140px"
@@ -197,6 +250,7 @@
 			<DevBuildBadge commitHash={__BUILD_HASH__} buildTime={__BUILD_TIME__} />
 		</div>
 	</SplitPaneContainer>
+	<SessionExpiredBanner locale="de" loginHref="/login" />
 {/if}
 
 <style>
diff --git a/apps/nutriphi/apps/web/src/lib/utils/meal-parser.test.ts b/apps/nutriphi/apps/web/src/lib/utils/meal-parser.test.ts
new file mode 100644
index 000000000..21ecc2deb
--- /dev/null
+++ b/apps/nutriphi/apps/web/src/lib/utils/meal-parser.test.ts
@@ -0,0 +1,83 @@
+import { describe, it, expect } from 'vitest';
+import { parseMealInput, formatParsedMealPreview } from './meal-parser';
+
+describe('parseMealInput', () => {
+	it('should parse food description', () => {
+		const result = parseMealInput('Spaghetti Bolognese');
+		expect(result.description).toBe('Spaghetti Bolognese');
+		expect(result.mealTypeExplicit).toBe(false);
+	});
+
+	it('should extract frühstück', () => {
+		const result = parseMealInput('2 Eier Toast Frühstück');
+		expect(result.description).toBe('2 Eier Toast');
+		expect(result.mealType).toBe('breakfast');
+		expect(result.mealTypeExplicit).toBe(true);
+	});
+
+	it('should extract mittagessen', () => {
+		const result = parseMealInput('Spaghetti Bolognese Mittagessen');
+		expect(result.description).toBe('Spaghetti Bolognese');
+		expect(result.mealType).toBe('lunch');
+		expect(result.mealTypeExplicit).toBe(true);
+	});
+
+	it('should extract abendessen', () => {
+		const result = parseMealInput('Pizza abendessen');
+		expect(result.description).toBe('Pizza');
+		expect(result.mealType).toBe('dinner');
+		expect(result.mealTypeExplicit).toBe(true);
+	});
+
+	it('should extract snack', () => {
+		const result = parseMealInput('Apfel snack');
+		expect(result.description).toBe('Apfel');
+		expect(result.mealType).toBe('snack');
+		expect(result.mealTypeExplicit).toBe(true);
+	});
+
+	it('should extract morgens/mittags/abends', () => {
+		expect(parseMealInput('Müsli morgens').mealType).toBe('breakfast');
+		expect(parseMealInput('Salat mittags').mealType).toBe('lunch');
+		expect(parseMealInput('Suppe abends').mealType).toBe('dinner');
+	});
+
+	it('should auto-detect meal type when not specified', () => {
+		const result = parseMealInput('Käsebrot');
+		expect(result.description).toBe('Käsebrot');
+		expect(result.mealTypeExplicit).toBe(false);
+		// mealType is auto-detected based on time of day
+		expect(['breakfast', 'lunch', 'dinner', 'snack']).toContain(result.mealType);
+	});
+
+	it('should handle empty input', () => {
+		const result = parseMealInput('');
+		expect(result.description).toBe('');
+	});
+
+	it('should handle comma-separated foods', () => {
+		const result = parseMealInput('Reis, Hähnchen, Brokkoli Mittagessen');
+		expect(result.description).toBe('Reis, Hähnchen, Brokkoli');
+		expect(result.mealType).toBe('lunch');
+	});
+});
+
+describe('formatParsedMealPreview', () => {
+	it('should show meal type', () => {
+		const parsed = parseMealInput('Toast Frühstück');
+		const preview = formatParsedMealPreview(parsed);
+		expect(preview).toContain('Frühstück');
+	});
+
+	it('should show auto-detection hint', () => {
+		const parsed = parseMealInput('Apfel');
+		const preview = formatParsedMealPreview(parsed);
+		expect(preview).toContain('automatisch');
+	});
+
+	it('should not show auto hint when explicit', () => {
+		const parsed = parseMealInput('Apfel snack');
+		const preview = formatParsedMealPreview(parsed);
+		expect(preview).not.toContain('automatisch');
+	});
+});
diff --git a/apps/nutriphi/apps/web/src/lib/utils/meal-parser.ts b/apps/nutriphi/apps/web/src/lib/utils/meal-parser.ts
new file mode 100644
index 000000000..1345c545c
--- /dev/null
+++ b/apps/nutriphi/apps/web/src/lib/utils/meal-parser.ts
@@ -0,0 +1,165 @@
+/**
+ * Meal Parser for NutriPhi App
+ *
+ * Parses natural language input for quick meal logging.
+ * Extracts meal type and food description for AI analysis.
+ *
+ * Examples:
+ * - "Spaghetti Bolognese mittagessen"
+ * - "2 Eier, Toast, Orangensaft frühstück"
+ * - "Apfel snack"
+ * - "Hähnchenbrust mit Reis und Salat"
+ */
+
+import type { MealType } from '@nutriphi/shared';
+import { suggestMealType } from '@nutriphi/shared';
+import type { ParserLocale } from '@manacore/shared-utils';
+
+export interface ParsedMeal {
+	description: string;
+	mealType: MealType;
+	mealTypeExplicit: boolean; // Was meal type explicitly mentioned?
+}
+
+// Meal type patterns per locale
+const MEAL_TYPE_PATTERNS_BY_LOCALE: Record<ParserLocale, { pattern: RegExp; type: MealType }[]> = {
+	de: [
+		{ pattern: /\bfrühstück\b/i, type: 'breakfast' },
+		{ pattern: /\bmittagessen\b/i, type: 'lunch' },
+		{ pattern: /\babendessen\b/i, type: 'dinner' },
+		{ pattern: /\bsnack\b/i, type: 'snack' },
+		{ pattern: /\bmorgens\b/i, type: 'breakfast' },
+		{ pattern: /\bmittags\b/i, type: 'lunch' },
+		{ pattern: /\babends\b/i, type: 'dinner' },
+		{ pattern: /\bnachtisch\b/i, type: 'snack' },
+		{ pattern: /\bzwischenmahlzeit\b/i, type: 'snack' },
+	],
+	en: [
+		{ pattern: /\bbreakfast\b/i, type: 'breakfast' },
+		{ pattern: /\blunch\b/i, type: 'lunch' },
+		{ pattern: /\bdinner\b/i, type: 'dinner' },
+		{ pattern: /\bsnack\b/i, type: 'snack' },
+		{ pattern: /\bmorning\b/i, type: 'breakfast' },
+		{ pattern: /\bnoon\b/i, type: 'lunch' },
+		{ pattern: /\bevening\b/i, type: 'dinner' },
+	],
+	fr: [
+		{ pattern: /\bpetit[- ]d[ée]jeuner\b/i, type: 'breakfast' },
+		{ pattern: /\bd[ée]jeuner\b/i, type: 'lunch' },
+		{ pattern: /\bd[îi]ner\b/i, type: 'dinner' },
+		{ pattern: /\bgo[ûu]ter\b/i, type: 'snack' },
+		{ pattern: /\bmatin\b/i, type: 'breakfast' },
+		{ pattern: /\bmidi\b/i, type: 'lunch' },
+		{ pattern: /\bsoir\b/i, type: 'dinner' },
+	],
+	es: [
+		{ pattern: /\bdesayuno\b/i, type: 'breakfast' },
+		{ pattern: /\balmuerzo\b/i, type: 'lunch' },
+		{ pattern: /\bcena\b/i, type: 'dinner' },
+		{ pattern: /\bmerienda\b/i, type: 'snack' },
+	],
+	it: [
+		{ pattern: /\bcolazione\b/i, type: 'breakfast' },
+		{ pattern: /\bpranzo\b/i, type: 'lunch' },
+		{ pattern: /\bcena\b/i, type: 'dinner' },
+		{ pattern: /\bspuntino\b/i, type: 'snack' },
+	],
+};
+
+// Meal type labels per locale
+const MEAL_TYPE_LABELS_BY_LOCALE: Record<ParserLocale, Record<MealType, string>> = {
+	de: {
+		breakfast: 'Frühstück',
+		lunch: 'Mittagessen',
+		dinner: 'Abendessen',
+		snack: 'Snack',
+	},
+	en: {
+		breakfast: 'Breakfast',
+		lunch: 'Lunch',
+		dinner: 'Dinner',
+		snack: 'Snack',
+	},
+	fr: {
+		breakfast: 'Petit-déjeuner',
+		lunch: 'Déjeuner',
+		dinner: 'Dîner',
+		snack: 'Goûter',
+	},
+	es: {
+		breakfast: 'Desayuno',
+		lunch: 'Almuerzo',
+		dinner: 'Cena',
+		snack: 'Merienda',
+	},
+	it: {
+		breakfast: 'Colazione',
+		lunch: 'Pranzo',
+		dinner: 'Cena',
+		snack: 'Spuntino',
+	},
+};
+
+// Auto-detection hint per locale
+const AUTO_HINT_BY_LOCALE: Record<ParserLocale, string> = {
+	de: 'automatisch',
+	en: 'auto-detected',
+	fr: 'automatique',
+	es: 'automático',
+	it: 'automatico',
+};
+
+function extractMealType(
+	text: string,
+	locale: ParserLocale = 'de'
+): { mealType?: MealType; remaining: string } {
+	const patterns = MEAL_TYPE_PATTERNS_BY_LOCALE[locale];
+	for (const { pattern, type } of patterns) {
+		if (pattern.test(text)) {
+			return {
+				mealType: type,
+				remaining: text.replace(pattern, '').trim(),
+			};
+		}
+	}
+	return { mealType: undefined, remaining: text };
+}
+
+/**
+ * Parse natural language meal input
+ */
+export function parseMealInput(input: string, locale: ParserLocale = 'de'): ParsedMeal {
+	let text = input.trim();
+
+	// Extract explicit meal type
+	const mealTypeResult = extractMealType(text, locale);
+	text = mealTypeResult.remaining;
+
+	// Clean up description
+	const description = text.replace(/\s+/g, ' ').trim();
+
+	// Use explicit meal type or auto-detect based on time of day
+	const mealType = mealTypeResult.mealType || suggestMealType();
+
+	return {
+		description,
+		mealType,
+		mealTypeExplicit: !!mealTypeResult.mealType,
+	};
+}
+
+/**
+ * Format parsed meal for preview display
+ */
+export function formatParsedMealPreview(parsed: ParsedMeal, locale: ParserLocale = 'de'): string {
+	const parts: string[] = [];
+
+	const labels = MEAL_TYPE_LABELS_BY_LOCALE[locale];
+	parts.push(`🍽️ ${labels[parsed.mealType]}`);
+
+	if (!parsed.mealTypeExplicit) {
+		parts.push(`(${AUTO_HINT_BY_LOCALE[locale]})`);
+	}
+
+	return parts.join(' ');
+}
diff --git a/apps/nutriphi/apps/web/src/routes/+layout.svelte b/apps/nutriphi/apps/web/src/routes/+layout.svelte
index 3bcb1587f..a590fec6a 100644
--- a/apps/nutriphi/apps/web/src/routes/+layout.svelte
+++ b/apps/nutriphi/apps/web/src/routes/+layout.svelte
@@ -2,7 +2,13 @@
 	import '../app.css';
 	import '$lib/i18n';
 	import { isLoading as i18nLoading, _ as t } from 'svelte-i18n';
+	import { goto } from '$app/navigation';
+	import { QuickInputBar } from '@manacore/shared-ui';
+	import type { QuickInputItem, CreatePreview } from '@manacore/shared-ui';
 	import { authStore } from '$lib/stores/auth.svelte';
+	import { mealsStore } from '$lib/stores/meals.svelte';
+	import { parseMealInput, formatParsedMealPreview } from '$lib/utils/meal-parser';
+	import { SessionExpiredBanner } from '@manacore/shared-auth-ui';
 	import { onMount } from 'svelte';
 
 	let { children } = $props();
@@ -10,6 +16,46 @@
 	let loading = $state(true);
 	let appReady = $derived(!loading && !$i18nLoading);
 
+	// QuickInputBar handlers - search recent meals
+	async function handleSearch(query: string): Promise<QuickInputItem[]> {
+		const q = query.toLowerCase();
+		return mealsStore.meals
+			.filter((m) => m.description?.toLowerCase().includes(q))
+			.slice(0, 10)
+			.map((meal) => ({
+				id: meal.id,
+				title: meal.description || 'Mahlzeit',
+				subtitle: meal.mealType,
+			}));
+	}
+
+	function handleSelect(item: QuickInputItem) {
+		// No detail page for meals - just scroll to it
+	}
+
+	function handleParseCreate(query: string): CreatePreview | null {
+		if (!query.trim()) return null;
+		const parsed = parseMealInput(query);
+		if (!parsed.description) return null;
+		return {
+			title: `"${parsed.description}" analysieren`,
+			subtitle: formatParsedMealPreview(parsed),
+		};
+	}
+
+	async function handleCreate(query: string): Promise<void> {
+		if (!query.trim()) return;
+		const parsed = parseMealInput(query);
+		if (!parsed.description) return;
+		// Navigate to add page with pre-filled description and meal type
+		const params = new URLSearchParams({
+			type: 'text',
+			description: parsed.description,
+			mealType: parsed.mealType,
+		});
+		goto(`/add?${params.toString()}`);
+	}
+
 	onMount(() => {
 		authStore.initialize().then(() => {
 			loading = false;
@@ -33,4 +79,22 @@
 	</div>
 {:else}
 	{@render children()}
+
+	{#if authStore.isAuthenticated}
+		<QuickInputBar
+			onSearch={handleSearch}
+			onSelect={handleSelect}
+			onParseCreate={handleParseCreate}
+			onCreate={handleCreate}
+			placeholder="Mahlzeit eingeben..."
+			emptyText="Keine Mahlzeiten gefunden"
+			searchingText="Suche..."
+			createText="Analysieren"
+			deferSearch={true}
+			locale="de"
+			appIcon="search"
+			bottomOffset="70px"
+		/>
+	{/if}
+	<SessionExpiredBanner locale="de" loginHref="/login" />
 {/if}
diff --git a/apps/planta/apps/web/src/lib/utils/plant-parser.test.ts b/apps/planta/apps/web/src/lib/utils/plant-parser.test.ts
new file mode 100644
index 000000000..bce61f093
--- /dev/null
+++ b/apps/planta/apps/web/src/lib/utils/plant-parser.test.ts
@@ -0,0 +1,89 @@
+import { describe, it, expect } from 'vitest';
+import { parsePlantInput, resolvePlantData, formatParsedPlantPreview } from './plant-parser';
+
+describe('parsePlantInput', () => {
+	it('should parse a simple name', () => {
+		const result = parsePlantInput('Monstera');
+		expect(result.name).toBe('Monstera');
+		expect(result.acquiredAt).toBeUndefined();
+		expect(result.tagNames).toEqual([]);
+	});
+
+	it('should parse name with tags', () => {
+		const result = parsePlantInput('Basilikum #kräuter #küche');
+		expect(result.name).toBe('Basilikum');
+		expect(result.tagNames).toEqual(['kräuter', 'küche']);
+	});
+
+	it('should parse acquisition date', () => {
+		const result = parsePlantInput('Ficus morgen gekauft');
+		expect(result.name).toBe('Ficus');
+		expect(result.acquiredAt).toBeDefined();
+	});
+
+	it('should default to today when "gekauft" without date', () => {
+		const result = parsePlantInput('Orchidee gekauft');
+		expect(result.name).toBe('Orchidee');
+		expect(result.acquiredAt).toBeDefined();
+		expect(result.acquiredAt!.toDateString()).toBe(new Date().toDateString());
+	});
+
+	it('should parse "gepflanzt" as acquisition', () => {
+		const result = parsePlantInput('Tomate heute gepflanzt');
+		expect(result.name).toBe('Tomate');
+		expect(result.acquiredAt).toBeDefined();
+	});
+
+	it('should parse multi-word name', () => {
+		const result = parsePlantInput('Monstera deliciosa');
+		expect(result.name).toBe('Monstera deliciosa');
+	});
+
+	it('should handle empty input', () => {
+		const result = parsePlantInput('');
+		expect(result.name).toBe('');
+		expect(result.tagNames).toEqual([]);
+	});
+
+	it('should parse complex input', () => {
+		const result = parsePlantInput('Aloe Vera heute gekauft #sukkulente #badezimmer');
+		expect(result.name).toBe('Aloe Vera');
+		expect(result.acquiredAt).toBeDefined();
+		expect(result.tagNames).toEqual(['sukkulente', 'badezimmer']);
+	});
+});
+
+describe('resolvePlantData', () => {
+	it('should produce ISO date string', () => {
+		const parsed = parsePlantInput('Ficus heute gekauft');
+		const resolved = resolvePlantData(parsed);
+		expect(resolved.name).toBe('Ficus');
+		expect(resolved.acquiredAt).toBeDefined();
+		expect(new Date(resolved.acquiredAt!).toISOString()).toBe(resolved.acquiredAt);
+	});
+
+	it('should handle no date', () => {
+		const parsed = parsePlantInput('Monstera');
+		const resolved = resolvePlantData(parsed);
+		expect(resolved.acquiredAt).toBeUndefined();
+	});
+});
+
+describe('formatParsedPlantPreview', () => {
+	it('should format date', () => {
+		const parsed = parsePlantInput('Ficus heute gekauft');
+		const preview = formatParsedPlantPreview(parsed);
+		expect(preview).toContain('Heute');
+	});
+
+	it('should format tags', () => {
+		const parsed = parsePlantInput('Monstera #tropisch');
+		const preview = formatParsedPlantPreview(parsed);
+		expect(preview).toContain('tropisch');
+	});
+
+	it('should return empty for name-only', () => {
+		const parsed = parsePlantInput('Monstera');
+		expect(formatParsedPlantPreview(parsed)).toBe('');
+	});
+});
diff --git a/apps/planta/apps/web/src/lib/utils/plant-parser.ts b/apps/planta/apps/web/src/lib/utils/plant-parser.ts
new file mode 100644
index 000000000..94900bfa0
--- /dev/null
+++ b/apps/planta/apps/web/src/lib/utils/plant-parser.ts
@@ -0,0 +1,117 @@
+/**
+ * Plant Parser for Planta App
+ *
+ * Extends the base parser with plant-specific patterns:
+ * - Scientific names (italic Latin names)
+ * - Acquisition date
+ * - Tags for categories
+ *
+ * Examples:
+ * - "Monstera deliciosa #tropisch"
+ * - "Basilikum heute gekauft #kräuter"
+ * - "Ficus benjamina morgen #zimmerpflanze"
+ */
+
+import {
+	parseBaseInput,
+	extractTags,
+	combineDateAndTime,
+	formatDatePreview,
+	type ParserLocale,
+} from '@manacore/shared-utils';
+
+export interface ParsedPlant {
+	name: string;
+	acquiredAt?: Date;
+	tagNames: string[];
+}
+
+export interface ParsedPlantWithIds {
+	name: string;
+	acquiredAt?: string;
+}
+
+// Acquisition keywords per locale
+const ACQUIRED_PATTERNS_BY_LOCALE: Record<ParserLocale, RegExp[]> = {
+	de: [/\bgekauft\b/i, /\bbekommen\b/i, /\berhalten\b/i, /\bgepflanzt\b/i],
+	en: [/\bbought\b/i, /\breceived\b/i, /\bgot\b/i, /\bplanted\b/i],
+	fr: [/\bacheté\b/i, /\breçu\b/i, /\bplanté\b/i],
+	es: [/\bcomprado\b/i, /\brecibido\b/i, /\bplantado\b/i],
+	it: [/\bcomprato\b/i, /\bricevuto\b/i, /\bpiantato\b/i],
+};
+
+function extractAcquiredKeyword(
+	text: string,
+	locale: ParserLocale = 'de'
+): { found: boolean; remaining: string } {
+	const patterns = ACQUIRED_PATTERNS_BY_LOCALE[locale];
+	for (const pattern of patterns) {
+		if (pattern.test(text)) {
+			return {
+				found: true,
+				remaining: text.replace(pattern, '').trim(),
+			};
+		}
+	}
+	return { found: false, remaining: text };
+}
+
+/**
+ * Parse natural language plant input
+ *
+ * Examples:
+ * - "Monstera #tropisch"
+ * - "Basilikum heute gekauft #kräuter"
+ * - "Ficus benjamina"
+ */
+export function parsePlantInput(input: string, locale: ParserLocale = 'de'): ParsedPlant {
+	let text = input.trim();
+
+	// Check for acquisition keywords
+	const acquiredResult = extractAcquiredKeyword(text, locale);
+	text = acquiredResult.remaining;
+
+	// Use base parser for date, time, tags
+	const base = parseBaseInput(text, locale);
+
+	// If we found a date (or acquisition keyword implies today)
+	let acquiredAt: Date | undefined;
+	if (base.date) {
+		acquiredAt = combineDateAndTime(base.date, base.time);
+	} else if (acquiredResult.found) {
+		acquiredAt = new Date(); // "gekauft" without date = today
+	}
+
+	return {
+		name: base.title,
+		acquiredAt,
+		tagNames: base.tagNames,
+	};
+}
+
+/**
+ * Resolve to API-ready format
+ */
+export function resolvePlantData(parsed: ParsedPlant): ParsedPlantWithIds {
+	return {
+		name: parsed.name,
+		acquiredAt: parsed.acquiredAt?.toISOString(),
+	};
+}
+
+/**
+ * Format parsed plant for preview display
+ */
+export function formatParsedPlantPreview(parsed: ParsedPlant, locale: ParserLocale = 'de'): string {
+	const parts: string[] = [];
+
+	if (parsed.acquiredAt) {
+		parts.push(`📅 ${formatDatePreview(parsed.acquiredAt, locale)}`);
+	}
+
+	if (parsed.tagNames.length > 0) {
+		parts.push(`🏷️ ${parsed.tagNames.join(', ')}`);
+	}
+
+	return parts.join(' · ');
+}
diff --git a/apps/planta/apps/web/src/routes/(app)/+layout.svelte b/apps/planta/apps/web/src/routes/(app)/+layout.svelte
index 9833d96f1..763857567 100644
--- a/apps/planta/apps/web/src/routes/(app)/+layout.svelte
+++ b/apps/planta/apps/web/src/routes/(app)/+layout.svelte
@@ -3,10 +3,16 @@
 	import { page } from '$app/stores';
 	import { onMount } from 'svelte';
 	import { PillNavigation, QuickInputBar } from '@manacore/shared-ui';
-	import type { PillNavItem, QuickInputItem } from '@manacore/shared-ui';
+	import type { PillNavItem, QuickInputItem, CreatePreview } from '@manacore/shared-ui';
 	import { theme } from '$lib/stores/theme';
 	import { authStore } from '$lib/stores/auth.svelte';
 	import { plantsApi } from '$lib/api/plants';
+	import {
+		parsePlantInput,
+		resolvePlantData,
+		formatParsedPlantPreview,
+	} from '$lib/utils/plant-parser';
+	import { SessionExpiredBanner } from '@manacore/shared-auth-ui';
 
 	let { children } = $props();
 
@@ -54,6 +60,32 @@
 		goto(`/plant/${item.id}`);
 	}
 
+	// Quick-Create handlers
+	function handleParseCreate(query: string): CreatePreview | null {
+		if (!query.trim()) return null;
+		const parsed = parsePlantInput(query);
+		if (!parsed.name) return null;
+		const preview = formatParsedPlantPreview(parsed);
+		return {
+			title: `"${parsed.name}" erstellen`,
+			subtitle: preview || 'Neue Pflanze',
+		};
+	}
+
+	async function handleCreate(query: string): Promise<void> {
+		if (!query.trim()) return;
+		const parsed = parsePlantInput(query);
+		if (!parsed.name) return;
+		const resolved = resolvePlantData(parsed);
+		const plant = await plantsApi.create({
+			name: resolved.name,
+			acquiredAt: resolved.acquiredAt,
+		});
+		if (plant?.id) {
+			goto(`/plant/${plant.id}`);
+		}
+	}
+
 	onMount(async () => {
 		// Initialize auth state from stored tokens
 		await authStore.initialize();
@@ -86,9 +118,13 @@
 		<QuickInputBar
 			onSearch={handleInputSearch}
 			onSelect={handleInputSelect}
-			placeholder="Pflanze suchen..."
+			onParseCreate={handleParseCreate}
+			onCreate={handleCreate}
+			placeholder="Neue Pflanze oder suchen..."
 			emptyText="Keine Pflanzen gefunden"
 			searchingText="Suche..."
+			createText="Erstellen"
+			deferSearch={true}
 			locale="de"
 			appIcon="search"
 			bottomOffset="70px"
@@ -100,6 +136,7 @@
 			</div>
 		</main>
 	</div>
+	<SessionExpiredBanner locale="de" loginHref="/login" />
 {:else}
 	<div class="flex min-h-screen items-center justify-center">
 		<div
diff --git a/apps/todo/apps/web/src/lib/utils/task-parser.ts b/apps/todo/apps/web/src/lib/utils/task-parser.ts
index d6cc251a1..4f08e9eef 100644
--- a/apps/todo/apps/web/src/lib/utils/task-parser.ts
+++ b/apps/todo/apps/web/src/lib/utils/task-parser.ts
@@ -13,6 +13,7 @@ import {
 	formatDatePreview,
 	formatTimePreview,
 } from '@manacore/shared-utils';
+import type { ParserLocale } from '@manacore/shared-utils';
 import type { TaskPriority } from '@todo/shared';
 
 export interface ParsedTask {
@@ -41,20 +42,42 @@ export interface ParsedTaskWithIds {
 	labelIds: string[];
 }
 
-// Priority patterns (task-specific)
-// Supports: später, normal, wichtig, dringend (with or without !) and shortcuts !, !!, !!!
-const PRIORITY_PATTERNS: { pattern: RegExp; priority: TaskPriority }[] = [
-	{ pattern: /!{3,}|!?dringend\b/i, priority: 'urgent' },
-	{ pattern: /!{2}|!?wichtig\b/i, priority: 'high' },
-	{ pattern: /!?normal\b/i, priority: 'medium' },
-	{ pattern: /!?sp[aä]ter\b/i, priority: 'low' },
-];
+// Priority keyword translations per locale
+const PRIORITY_KEYWORDS: Record<
+	ParserLocale,
+	{ urgent: string; high: string; medium: string; low: string }
+> = {
+	de: { urgent: 'dringend', high: 'wichtig', medium: 'normal', low: 'sp[aä]ter' },
+	en: { urgent: 'urgent', high: 'important', medium: 'normal', low: 'later' },
+	fr: { urgent: 'urgent', high: 'important', medium: 'normal', low: 'plus\\s+tard' },
+	es: { urgent: 'urgente', high: 'importante', medium: 'normal', low: 'despu[eé]s' },
+	it: { urgent: 'urgente', high: 'importante', medium: 'normale', low: 'dopo' },
+};
+
+/**
+ * Build locale-aware priority patterns
+ */
+function buildPriorityPatterns(
+	locale: ParserLocale
+): { pattern: RegExp; priority: TaskPriority }[] {
+	const kw = PRIORITY_KEYWORDS[locale];
+	return [
+		{ pattern: new RegExp(`!{3,}|!?${kw.urgent}\\b`, 'i'), priority: 'urgent' },
+		{ pattern: new RegExp(`!{2}|!?${kw.high}\\b`, 'i'), priority: 'high' },
+		{ pattern: new RegExp(`!?${kw.medium}\\b`, 'i'), priority: 'medium' },
+		{ pattern: new RegExp(`!?${kw.low}\\b`, 'i'), priority: 'low' },
+	];
+}
 
 /**
  * Extract priority from text
  */
-function extractPriority(text: string): { priority?: TaskPriority; remaining: string } {
-	for (const { pattern, priority } of PRIORITY_PATTERNS) {
+function extractPriority(
+	text: string,
+	locale: ParserLocale = 'de'
+): { priority?: TaskPriority; remaining: string } {
+	const patterns = buildPriorityPatterns(locale);
+	for (const { pattern, priority } of patterns) {
 		if (pattern.test(text)) {
 			return {
 				priority,
@@ -73,11 +96,11 @@ function extractPriority(text: string): { priority?: TaskPriority; remaining: st
  * - "Einkaufen heute #privat"
  * - "Report in 3 Tagen !!"
  */
-export function parseTaskInput(input: string): ParsedTask {
+export function parseTaskInput(input: string, locale: ParserLocale = 'de'): ParsedTask {
 	let text = input.trim();
 
 	// Extract priority first (task-specific)
-	const priorityResult = extractPriority(text);
+	const priorityResult = extractPriority(text, locale);
 	text = priorityResult.remaining;
 	const priority = priorityResult.priority;
 
@@ -87,7 +110,7 @@ export function parseTaskInput(input: string): ParsedTask {
 	const projectName = projectResult.value;
 
 	// Use base parser for common patterns (date, time, tags)
-	const base = parseBaseInput(text);
+	const base = parseBaseInput(text, locale);
 
 	// Combine date and time
 	const dueDate = combineDateAndTime(base.date, base.time);
@@ -139,10 +162,19 @@ export function resolveTaskIds(
 	};
 }
 
+// Priority display labels per locale
+const PRIORITY_LABELS: Record<ParserLocale, Record<TaskPriority, string>> = {
+	de: { low: '🟢 Später', medium: '🟡 Normal', high: '🟠 Wichtig', urgent: '🔴 Dringend' },
+	en: { low: '🟢 Later', medium: '🟡 Normal', high: '🟠 Important', urgent: '🔴 Urgent' },
+	fr: { low: '🟢 Plus tard', medium: '🟡 Normal', high: '🟠 Important', urgent: '🔴 Urgent' },
+	es: { low: '🟢 Después', medium: '🟡 Normal', high: '🟠 Importante', urgent: '🔴 Urgente' },
+	it: { low: '🟢 Dopo', medium: '🟡 Normale', high: '🟠 Importante', urgent: '🔴 Urgente' },
+};
+
 /**
  * Format parsed task for preview display
  */
-export function formatParsedTaskPreview(parsed: ParsedTask): string {
+export function formatParsedTaskPreview(parsed: ParsedTask, locale: ParserLocale = 'de'): string {
 	const parts: string[] = [];
 
 	if (parsed.dueDate) {
@@ -160,13 +192,7 @@ export function formatParsedTaskPreview(parsed: ParsedTask): string {
 	}
 
 	if (parsed.priority) {
-		const priorityLabels: Record<TaskPriority, string> = {
-			low: '🟢 Später',
-			medium: '🟡 Normal',
-			high: '🟠 Wichtig',
-			urgent: '🔴 Dringend',
-		};
-		parts.push(priorityLabels[parsed.priority]);
+		parts.push(PRIORITY_LABELS[locale][parsed.priority]);
 	}
 
 	if (parsed.projectName) {
diff --git a/packages/shared-utils/src/parsers/base-parser.test.ts b/packages/shared-utils/src/parsers/base-parser.test.ts
new file mode 100644
index 000000000..6fde949fc
--- /dev/null
+++ b/packages/shared-utils/src/parsers/base-parser.test.ts
@@ -0,0 +1,697 @@
+import { describe, it, expect } from 'vitest';
+import {
+	extractDate,
+	extractDateRange,
+	extractTime,
+	extractTimezone,
+	extractAtReferences,
+	extractRecurrence,
+	extractRelativeTime,
+	fuzzyMatchDateKeyword,
+	createAppParser,
+	parseBaseInput,
+	formatDatePreview,
+} from './base-parser';
+import { addDays } from 'date-fns';
+
+// ============================================================================
+// German (de) - was already working, verify still works
+// ============================================================================
+
+describe('German (de)', () => {
+	it('should parse "heute"', () => {
+		const result = extractDate('Meeting heute', 'de');
+		expect(result.value).toBeDefined();
+		expect(result.value!.toDateString()).toBe(new Date().toDateString());
+		expect(result.remaining).toBe('Meeting');
+	});
+
+	it('should parse "morgen"', () => {
+		const result = extractDate('morgen Termin', 'de');
+		expect(result.value).toBeDefined();
+		expect(result.value!.toDateString()).toBe(addDays(new Date(), 1).toDateString());
+	});
+
+	it('should parse "übermorgen"', () => {
+		const result = extractDate('übermorgen', 'de');
+		expect(result.value).toBeDefined();
+		expect(result.value!.toDateString()).toBe(addDays(new Date(), 2).toDateString());
+	});
+
+	it('should parse "in 3 Tagen"', () => {
+		const result = extractDate('in 3 Tagen', 'de');
+		expect(result.value).toBeDefined();
+		expect(result.value!.toDateString()).toBe(addDays(new Date(), 3).toDateString());
+	});
+
+	it('should parse "14 Uhr"', () => {
+		const result = extractTime('um 14 Uhr', 'de');
+		expect(result.value).toEqual({ hours: 14, minutes: 0 });
+	});
+
+	it('should parse DD.MM. date', () => {
+		const result = extractDate('15.12.', 'de');
+		expect(result.value).toBeDefined();
+		expect(result.value!.getDate()).toBe(15);
+		expect(result.value!.getMonth()).toBe(11); // December
+	});
+
+	it('should format preview as Heute/Morgen', () => {
+		expect(formatDatePreview(new Date(), 'de')).toBe('Heute');
+		expect(formatDatePreview(addDays(new Date(), 1), 'de')).toBe('Morgen');
+	});
+});
+
+// ============================================================================
+// English (en)
+// ============================================================================
+
+describe('English (en)', () => {
+	it('should parse "today"', () => {
+		const result = extractDate('Meeting today', 'en');
+		expect(result.value).toBeDefined();
+		expect(result.value!.toDateString()).toBe(new Date().toDateString());
+		expect(result.remaining).toBe('Meeting');
+	});
+
+	it('should parse "tomorrow"', () => {
+		const result = extractDate('tomorrow meeting', 'en');
+		expect(result.value).toBeDefined();
+		expect(result.value!.toDateString()).toBe(addDays(new Date(), 1).toDateString());
+	});
+
+	it('should parse "in 5 days"', () => {
+		const result = extractDate('in 5 days', 'en');
+		expect(result.value).toBeDefined();
+		expect(result.value!.toDateString()).toBe(addDays(new Date(), 5).toDateString());
+	});
+
+	it('should parse "next week"', () => {
+		const result = extractDate('next week', 'en');
+		expect(result.value).toBeDefined();
+		expect(result.value!.toDateString()).toBe(addDays(new Date(), 7).toDateString());
+	});
+
+	it('should parse weekday "monday"', () => {
+		const result = extractDate('monday meeting', 'en');
+		expect(result.value).toBeDefined();
+		expect(result.value!.getDay()).toBe(1); // Monday
+	});
+
+	it('should parse "next friday"', () => {
+		const result = extractDate('next friday', 'en');
+		expect(result.value).toBeDefined();
+		expect(result.value!.getDay()).toBe(5); // Friday
+	});
+
+	it('should parse "at 2pm"', () => {
+		const result = extractTime('at 2pm', 'en');
+		expect(result.value).toEqual({ hours: 14, minutes: 0 });
+	});
+
+	it('should parse "3:30"', () => {
+		const result = extractTime('3:30', 'en');
+		expect(result.value).toEqual({ hours: 3, minutes: 30 });
+	});
+
+	it('should parse MM/DD date', () => {
+		const result = extractDate('12/25', 'en');
+		expect(result.value).toBeDefined();
+		expect(result.value!.getMonth()).toBe(11); // December
+		expect(result.value!.getDate()).toBe(25);
+	});
+
+	it('should format preview as Today/Tomorrow', () => {
+		expect(formatDatePreview(new Date(), 'en')).toBe('Today');
+		expect(formatDatePreview(addDays(new Date(), 1), 'en')).toBe('Tomorrow');
+	});
+
+	it('should parse full input in English', () => {
+		const result = parseBaseInput('Meeting tomorrow 14:00 #important', 'en');
+		expect(result.title).toBe('Meeting');
+		expect(result.date).toBeDefined();
+		expect(result.time).toEqual({ hours: 14, minutes: 0 });
+		expect(result.tagNames).toEqual(['important']);
+	});
+});
+
+// ============================================================================
+// French (fr)
+// ============================================================================
+
+describe('French (fr)', () => {
+	it('should parse "demain"', () => {
+		const result = extractDate('réunion demain', 'fr');
+		expect(result.value).toBeDefined();
+		expect(result.value!.toDateString()).toBe(addDays(new Date(), 1).toDateString());
+	});
+
+	it('should parse "dans 3 jours"', () => {
+		const result = extractDate('dans 3 jours', 'fr');
+		expect(result.value).toBeDefined();
+		expect(result.value!.toDateString()).toBe(addDays(new Date(), 3).toDateString());
+	});
+
+	it('should parse weekday "lundi"', () => {
+		const result = extractDate('lundi réunion', 'fr');
+		expect(result.value).toBeDefined();
+		expect(result.value!.getDay()).toBe(1); // Monday
+	});
+
+	it('should parse time "14h30"', () => {
+		const result = extractTime('à 14h30', 'fr');
+		expect(result.value).toEqual({ hours: 14, minutes: 30 });
+	});
+
+	it("should format preview as Aujourd'hui/Demain", () => {
+		expect(formatDatePreview(new Date(), 'fr')).toBe("Aujourd'hui");
+		expect(formatDatePreview(addDays(new Date(), 1), 'fr')).toBe('Demain');
+	});
+});
+
+// ============================================================================
+// Spanish (es)
+// ============================================================================
+
+describe('Spanish (es)', () => {
+	it('should parse "hoy"', () => {
+		const result = extractDate('reunión hoy', 'es');
+		expect(result.value).toBeDefined();
+		expect(result.value!.toDateString()).toBe(new Date().toDateString());
+	});
+
+	it('should parse "mañana"', () => {
+		const result = extractDate('mañana reunión', 'es');
+		expect(result.value).toBeDefined();
+		expect(result.value!.toDateString()).toBe(addDays(new Date(), 1).toDateString());
+	});
+
+	it('should parse "en 2 días"', () => {
+		const result = extractDate('en 2 días', 'es');
+		expect(result.value).toBeDefined();
+		expect(result.value!.toDateString()).toBe(addDays(new Date(), 2).toDateString());
+	});
+
+	it('should parse weekday "lunes"', () => {
+		const result = extractDate('lunes', 'es');
+		expect(result.value).toBeDefined();
+		expect(result.value!.getDay()).toBe(1);
+	});
+
+	it('should format preview as Hoy/Mañana', () => {
+		expect(formatDatePreview(new Date(), 'es')).toBe('Hoy');
+		expect(formatDatePreview(addDays(new Date(), 1), 'es')).toBe('Mañana');
+	});
+});
+
+// ============================================================================
+// Italian (it)
+// ============================================================================
+
+describe('Italian (it)', () => {
+	it('should parse "oggi"', () => {
+		const result = extractDate('riunione oggi', 'it');
+		expect(result.value).toBeDefined();
+		expect(result.value!.toDateString()).toBe(new Date().toDateString());
+	});
+
+	it('should parse "domani"', () => {
+		const result = extractDate('domani riunione', 'it');
+		expect(result.value).toBeDefined();
+		expect(result.value!.toDateString()).toBe(addDays(new Date(), 1).toDateString());
+	});
+
+	it('should parse "dopodomani"', () => {
+		const result = extractDate('dopodomani', 'it');
+		expect(result.value).toBeDefined();
+		expect(result.value!.toDateString()).toBe(addDays(new Date(), 2).toDateString());
+	});
+
+	it('should parse "tra 5 giorni"', () => {
+		const result = extractDate('tra 5 giorni', 'it');
+		expect(result.value).toBeDefined();
+		expect(result.value!.toDateString()).toBe(addDays(new Date(), 5).toDateString());
+	});
+
+	it('should parse weekday "lunedì"', () => {
+		const result = extractDate('lunedì', 'it');
+		expect(result.value).toBeDefined();
+		expect(result.value!.getDay()).toBe(1);
+	});
+
+	it('should format preview as Oggi/Domani', () => {
+		expect(formatDatePreview(new Date(), 'it')).toBe('Oggi');
+		expect(formatDatePreview(addDays(new Date(), 1), 'it')).toBe('Domani');
+	});
+});
+
+// ============================================================================
+// Multiple @references
+// ============================================================================
+
+describe('extractAtReferences', () => {
+	it('should extract multiple @references', () => {
+		const result = extractAtReferences('Meeting @Arbeit @Max');
+		expect(result.value).toEqual(['Arbeit', 'Max']);
+		expect(result.remaining).toBe('Meeting');
+	});
+
+	it('should extract single @reference', () => {
+		const result = extractAtReferences('Task @Projekt');
+		expect(result.value).toEqual(['Projekt']);
+	});
+
+	it('should return undefined for no references', () => {
+		const result = extractAtReferences('Just text');
+		expect(result.value).toBeUndefined();
+	});
+});
+
+// ============================================================================
+// Timezone Extraction
+// ============================================================================
+
+describe('Timezone', () => {
+	it('should extract CET', () => {
+		const result = extractTimezone('Meeting 14 Uhr CET');
+		expect(result.value).toBe('Europe/Berlin');
+		expect(result.remaining).toBe('Meeting 14 Uhr');
+	});
+
+	it('should extract EST', () => {
+		const result = extractTimezone('Call at 3pm EST');
+		expect(result.value).toBe('America/New_York');
+	});
+
+	it('should extract UTC', () => {
+		const result = extractTimezone('Deploy 10:00 UTC');
+		expect(result.value).toBe('UTC');
+	});
+
+	it('should return undefined for no timezone', () => {
+		const result = extractTimezone('Normal text');
+		expect(result.value).toBeUndefined();
+	});
+});
+
+// ============================================================================
+// Past Dates
+// ============================================================================
+
+describe('Past dates', () => {
+	it('should parse "gestern" (de)', () => {
+		const result = extractDate('gestern gemacht', 'de');
+		expect(result.value).toBeDefined();
+		expect(result.value!.toDateString()).toBe(addDays(new Date(), -1).toDateString());
+	});
+
+	it('should parse "vorgestern" (de)', () => {
+		const result = extractDate('vorgestern', 'de');
+		expect(result.value).toBeDefined();
+		expect(result.value!.toDateString()).toBe(addDays(new Date(), -2).toDateString());
+	});
+
+	it('should parse "yesterday" (en)', () => {
+		const result = extractDate('done yesterday', 'en');
+		expect(result.value).toBeDefined();
+		expect(result.value!.toDateString()).toBe(addDays(new Date(), -1).toDateString());
+	});
+
+	it('should parse "hier" (fr)', () => {
+		const result = extractDate('fait hier', 'fr');
+		expect(result.value).toBeDefined();
+		expect(result.value!.toDateString()).toBe(addDays(new Date(), -1).toDateString());
+	});
+
+	it('should parse "ieri" (it)', () => {
+		const result = extractDate('fatto ieri', 'it');
+		expect(result.value).toBeDefined();
+		expect(result.value!.toDateString()).toBe(addDays(new Date(), -1).toDateString());
+	});
+});
+
+// ============================================================================
+// Relative Week Expressions
+// ============================================================================
+
+describe('Relative weeks', () => {
+	it('should parse "übernächste Woche" (de)', () => {
+		const result = extractDate('übernächste Woche', 'de');
+		expect(result.value).toBeDefined();
+		expect(result.value!.toDateString()).toBe(addDays(new Date(), 14).toDateString());
+	});
+
+	it('should parse "week after next" (en)', () => {
+		const result = extractDate('week after next', 'en');
+		expect(result.value).toBeDefined();
+		expect(result.value!.toDateString()).toBe(addDays(new Date(), 14).toDateString());
+	});
+
+	it('should parse "in 3 Wochen" (de)', () => {
+		const result = extractDate('in 3 Wochen', 'de');
+		expect(result.value).toBeDefined();
+		// 3 weeks = 21 days
+		const expected = addDays(new Date(), 21);
+		expect(result.value!.toDateString()).toBe(expected.toDateString());
+	});
+
+	it('should parse "in 2 weeks" (en)', () => {
+		const result = extractDate('in 2 weeks', 'en');
+		expect(result.value).toBeDefined();
+		expect(result.value!.toDateString()).toBe(addDays(new Date(), 14).toDateString());
+	});
+});
+
+// ============================================================================
+// Month Names & Ordinal Dates
+// ============================================================================
+
+describe('Month names', () => {
+	it('should parse "im März" (de)', () => {
+		const result = extractDate('Termin im März', 'de');
+		expect(result.value).toBeDefined();
+		expect(result.value!.getMonth()).toBe(2); // March
+	});
+
+	it('should parse "in January" (en)', () => {
+		const result = extractDate('meeting in January', 'en');
+		expect(result.value).toBeDefined();
+		expect(result.value!.getMonth()).toBe(0); // January
+	});
+
+	it('should parse "en février" (fr)', () => {
+		const result = extractDate('réunion en février', 'fr');
+		expect(result.value).toBeDefined();
+		expect(result.value!.getMonth()).toBe(1); // February
+	});
+});
+
+describe('Ordinal dates', () => {
+	it('should parse "5. Dezember" (de)', () => {
+		const result = extractDate('Termin 5. Dezember', 'de');
+		expect(result.value).toBeDefined();
+		expect(result.value!.getDate()).toBe(5);
+		expect(result.value!.getMonth()).toBe(11); // December
+	});
+
+	it('should parse "3rd of May" (en)', () => {
+		const result = extractDate('meeting 3rd of May', 'en');
+		expect(result.value).toBeDefined();
+		expect(result.value!.getDate()).toBe(3);
+		expect(result.value!.getMonth()).toBe(4); // May
+	});
+
+	it('should parse "le 15 mars" (fr)', () => {
+		const result = extractDate('réunion le 15 mars', 'fr');
+		expect(result.value).toBeDefined();
+		expect(result.value!.getDate()).toBe(15);
+		expect(result.value!.getMonth()).toBe(2); // March
+	});
+
+	it('should parse "el 3 de mayo" (es)', () => {
+		const result = extractDate('reunión el 3 de mayo', 'es');
+		expect(result.value).toBeDefined();
+		expect(result.value!.getDate()).toBe(3);
+		expect(result.value!.getMonth()).toBe(4); // May
+	});
+});
+
+// ============================================================================
+// Recurrence Extraction
+// ============================================================================
+
+describe('Recurrence (de)', () => {
+	it('should parse "täglich"', () => {
+		const result = extractRecurrence('Standup täglich', 'de');
+		expect(result.value).toBe('FREQ=DAILY');
+		expect(result.remaining).toBe('Standup');
+	});
+
+	it('should parse "wöchentlich"', () => {
+		const result = extractRecurrence('Meeting wöchentlich', 'de');
+		expect(result.value).toBe('FREQ=WEEKLY');
+	});
+
+	it('should parse "jeden Montag"', () => {
+		const result = extractRecurrence('Standup jeden Montag', 'de');
+		expect(result.value).toBe('FREQ=WEEKLY;BYDAY=MO');
+	});
+
+	it('should parse "monatlich"', () => {
+		const result = extractRecurrence('Review monatlich', 'de');
+		expect(result.value).toBe('FREQ=MONTHLY');
+	});
+
+	it('should parse "alle 2 Wochen"', () => {
+		const result = extractRecurrence('Sprint alle 2 Wochen', 'de');
+		expect(result.value).toBe('FREQ=WEEKLY;INTERVAL=2');
+	});
+
+	it('should return undefined for no recurrence', () => {
+		const result = extractRecurrence('Einfacher Termin', 'de');
+		expect(result.value).toBeUndefined();
+	});
+});
+
+describe('Recurrence (en)', () => {
+	it('should parse "daily"', () => {
+		const result = extractRecurrence('Standup daily', 'en');
+		expect(result.value).toBe('FREQ=DAILY');
+	});
+
+	it('should parse "every Monday"', () => {
+		const result = extractRecurrence('Standup every Monday', 'en');
+		expect(result.value).toBe('FREQ=WEEKLY;BYDAY=MO');
+	});
+
+	it('should parse "every 3 weeks"', () => {
+		const result = extractRecurrence('Sprint every 3 weeks', 'en');
+		expect(result.value).toBe('FREQ=WEEKLY;INTERVAL=3');
+	});
+
+	it('should parse "monthly"', () => {
+		const result = extractRecurrence('Review monthly', 'en');
+		expect(result.value).toBe('FREQ=MONTHLY');
+	});
+});
+
+describe('Recurrence (fr)', () => {
+	it('should parse "quotidien"', () => {
+		const result = extractRecurrence('Standup quotidien', 'fr');
+		expect(result.value).toBe('FREQ=DAILY');
+	});
+
+	it('should parse "chaque lundi"', () => {
+		const result = extractRecurrence('Réunion chaque lundi', 'fr');
+		expect(result.value).toBe('FREQ=WEEKLY;BYDAY=MO');
+	});
+});
+
+// ============================================================================
+// Relative Time Expressions
+// ============================================================================
+
+describe('Relative time (de)', () => {
+	it('should parse "in 2 Stunden"', () => {
+		const now = Date.now();
+		const result = extractRelativeTime('Meeting in 2 Stunden', 'de');
+		expect(result.value).toBeDefined();
+		const diff = result.value!.getTime() - now;
+		expect(diff).toBeGreaterThan(110 * 60_000); // ~2h
+		expect(diff).toBeLessThan(130 * 60_000);
+		expect(result.remaining).toBe('Meeting');
+	});
+
+	it('should parse "in 30 Minuten"', () => {
+		const now = Date.now();
+		const result = extractRelativeTime('Call in 30 Minuten', 'de');
+		expect(result.value).toBeDefined();
+		const diff = result.value!.getTime() - now;
+		expect(diff).toBeGreaterThan(25 * 60_000);
+		expect(diff).toBeLessThan(35 * 60_000);
+	});
+
+	it('should parse "in einer halben Stunde"', () => {
+		const now = Date.now();
+		const result = extractRelativeTime('Termin in einer halben Stunde', 'de');
+		expect(result.value).toBeDefined();
+		const diff = result.value!.getTime() - now;
+		expect(diff).toBeGreaterThan(25 * 60_000);
+		expect(diff).toBeLessThan(35 * 60_000);
+	});
+
+	it('should return undefined for no match', () => {
+		const result = extractRelativeTime('Normaler Text', 'de');
+		expect(result.value).toBeUndefined();
+	});
+});
+
+describe('Relative time (en)', () => {
+	it('should parse "in 2 hours"', () => {
+		const now = Date.now();
+		const result = extractRelativeTime('Meeting in 2 hours', 'en');
+		expect(result.value).toBeDefined();
+		const diff = result.value!.getTime() - now;
+		expect(diff).toBeGreaterThan(110 * 60_000);
+		expect(diff).toBeLessThan(130 * 60_000);
+	});
+
+	it('should parse "in half an hour"', () => {
+		const now = Date.now();
+		const result = extractRelativeTime('Call in half an hour', 'en');
+		expect(result.value).toBeDefined();
+		const diff = result.value!.getTime() - now;
+		expect(diff).toBeGreaterThan(25 * 60_000);
+		expect(diff).toBeLessThan(35 * 60_000);
+	});
+
+	it('should parse "in 15 minutes"', () => {
+		const result = extractRelativeTime('Break in 15 minutes', 'en');
+		expect(result.value).toBeDefined();
+	});
+});
+
+// ============================================================================
+// Fuzzy Matching
+// ============================================================================
+
+describe('Fuzzy matching', () => {
+	it('should match "morge" → "morgen"', () => {
+		expect(fuzzyMatchDateKeyword('morge', 'de')).toBe('morgen');
+	});
+
+	it('should match "motag" → "montag"', () => {
+		expect(fuzzyMatchDateKeyword('motag', 'de')).toBe('montag');
+	});
+
+	it('should match "donerstag" → "donnerstag"', () => {
+		expect(fuzzyMatchDateKeyword('donerstag', 'de')).toBe('donnerstag');
+	});
+
+	it('should match "tomorow" → "tomorrow" (en)', () => {
+		expect(fuzzyMatchDateKeyword('tomorow', 'en')).toBe('tomorrow');
+	});
+
+	it('should match "wedensday" → "wednesday" (en)', () => {
+		expect(fuzzyMatchDateKeyword('wedensday', 'en')).toBe('wednesday');
+	});
+
+	it('should not match completely wrong words', () => {
+		expect(fuzzyMatchDateKeyword('hallo', 'de')).toBeUndefined();
+	});
+
+	it('should extract date from fuzzy input "morge"', () => {
+		const result = extractDate('Meeting morge', 'de');
+		expect(result.value).toBeDefined();
+		expect(result.value!.toDateString()).toBe(addDays(new Date(), 1).toDateString());
+	});
+
+	it('should extract date from fuzzy input "donerstag"', () => {
+		const result = extractDate('Termin donerstag', 'de');
+		expect(result.value).toBeDefined();
+		expect(result.value!.getDay()).toBe(4); // Thursday
+	});
+});
+
+// ============================================================================
+// Date Range
+// ============================================================================
+
+describe('Date range', () => {
+	it('should parse "15.-17. März" (de)', () => {
+		const result = extractDateRange('Urlaub 15.-17. März', 'de');
+		expect(result.value).toBeDefined();
+		expect(result.value!.start.getDate()).toBe(15);
+		expect(result.value!.end.getDate()).toBe(17);
+		expect(result.value!.start.getMonth()).toBe(2); // March
+	});
+
+	it('should parse "3-5 May" (en)', () => {
+		const result = extractDateRange('Holiday 3-5 May', 'en');
+		expect(result.value).toBeDefined();
+		expect(result.value!.start.getDate()).toBe(3);
+		expect(result.value!.end.getDate()).toBe(5);
+		expect(result.value!.start.getMonth()).toBe(4); // May
+	});
+
+	it('should return undefined for no range', () => {
+		const result = extractDateRange('Normal text', 'de');
+		expect(result.value).toBeUndefined();
+	});
+});
+
+// ============================================================================
+// Confidence Score
+// ============================================================================
+
+describe('Confidence score', () => {
+	it('should return 1.0 for input with clear extractions', () => {
+		const result = parseBaseInput('Meeting morgen 14 Uhr #wichtig', 'de');
+		expect(result.confidence).toBe(1.0);
+	});
+
+	it('should return 0.5 for plain text with no extractions', () => {
+		const result = parseBaseInput('Einfacher Text', 'de');
+		expect(result.confidence).toBe(0.5);
+	});
+});
+
+// ============================================================================
+// Compose Helper
+// ============================================================================
+
+describe('createAppParser', () => {
+	it('should compose base + custom extractions', () => {
+		const { parse } = createAppParser('de', [
+			{
+				name: 'priority',
+				extract: (text: string) => {
+					if (/!!!/.test(text)) {
+						return { value: 'urgent', remaining: text.replace(/!!!/, '').trim() };
+					}
+					return { value: undefined, remaining: text };
+				},
+			},
+		]);
+
+		const result = parse('Task morgen !!! #arbeit');
+		expect(result.extractions.priority).toBe('urgent');
+		expect(result.base.date).toBeDefined();
+		expect(result.base.tagNames).toEqual(['arbeit']);
+		expect(result.base.title).toBe('Task');
+	});
+
+	it('should work with no custom steps', () => {
+		const { parse } = createAppParser('en', []);
+		const result = parse('Meeting tomorrow 14:00');
+		expect(result.base.date).toBeDefined();
+		expect(result.base.time).toEqual({ hours: 14, minutes: 0 });
+	});
+});
+
+// ============================================================================
+// Default locale (backward compat)
+// ============================================================================
+
+describe('Default locale (de)', () => {
+	it('extractDate defaults to de', () => {
+		const result = extractDate('heute');
+		expect(result.value).toBeDefined();
+	});
+
+	it('extractTime defaults to de', () => {
+		const result = extractTime('14 Uhr');
+		expect(result.value).toEqual({ hours: 14, minutes: 0 });
+	});
+
+	it('parseBaseInput defaults to de', () => {
+		const result = parseBaseInput('Meeting morgen 14 Uhr #wichtig');
+		expect(result.date).toBeDefined();
+		expect(result.time).toEqual({ hours: 14, minutes: 0 });
+		expect(result.tagNames).toEqual(['wichtig']);
+	});
+
+	it('formatDatePreview defaults to de', () => {
+		expect(formatDatePreview(new Date())).toBe('Heute');
+	});
+});
diff --git a/packages/shared-utils/src/parsers/base-parser.ts b/packages/shared-utils/src/parsers/base-parser.ts
index bb5c02fcc..d70b680e2 100644
--- a/packages/shared-utils/src/parsers/base-parser.ts
+++ b/packages/shared-utils/src/parsers/base-parser.ts
@@ -3,10 +3,15 @@
  *
  * Shared parsing utilities for date, time, and tags across all apps.
  * App-specific parsers (task-parser, event-parser, contact-parser) extend this.
+ *
+ * Supports locales: de, en, fr, es, it
  */
 
 import {
 	addDays,
+	addWeeks,
+	addHours,
+	addMinutes,
 	nextMonday,
 	nextTuesday,
 	nextWednesday,
@@ -16,14 +21,20 @@ import {
 	nextSunday,
 	setHours,
 	setMinutes,
+	isBefore,
+	startOfWeek,
 } from 'date-fns';
 
+export type ParserLocale = 'de' | 'en' | 'fr' | 'es' | 'it';
+
 export interface BaseParsedInput {
 	title: string;
 	date?: Date;
 	time?: { hours: number; minutes: number };
 	tagNames: string[];
 	rawInput: string;
+	/** Confidence score 0-1. 1.0 = exact match, 0.8 = fuzzy, 0.5 = ambiguous */
+	confidence: number;
 }
 
 export interface ExtractResult<T> {
@@ -32,7 +43,7 @@ export interface ExtractResult<T> {
 }
 
 // ============================================================================
-// Date Extraction
+// Locale-aware Pattern Definitions
 // ============================================================================
 
 interface DatePattern {
@@ -40,97 +51,776 @@ interface DatePattern {
 	getDate: (match?: RegExpMatchArray) => Date;
 }
 
-const DATE_PATTERNS: DatePattern[] = [
-	{ pattern: /\bheute\b/i, getDate: () => new Date() },
-	{ pattern: /\bmorgen\b/i, getDate: () => addDays(new Date(), 1) },
-	{ pattern: /\bübermorgen\b/i, getDate: () => addDays(new Date(), 2) },
-	{ pattern: /\bnächste[nr]?\s*woche\b/i, getDate: () => addDays(new Date(), 7) },
-	{ pattern: /\bnächste[nr]?\s*montag\b/i, getDate: () => nextMonday(new Date()) },
-	{ pattern: /\bnächste[nr]?\s*dienstag\b/i, getDate: () => nextTuesday(new Date()) },
-	{ pattern: /\bnächste[nr]?\s*mittwoch\b/i, getDate: () => nextWednesday(new Date()) },
-	{ pattern: /\bnächste[nr]?\s*donnerstag\b/i, getDate: () => nextThursday(new Date()) },
-	{ pattern: /\bnächste[nr]?\s*freitag\b/i, getDate: () => nextFriday(new Date()) },
-	{ pattern: /\bnächste[nr]?\s*samstag\b/i, getDate: () => nextSaturday(new Date()) },
-	{ pattern: /\bnächste[nr]?\s*sonntag\b/i, getDate: () => nextSunday(new Date()) },
-	{ pattern: /\bmontag\b/i, getDate: () => nextMonday(new Date()) },
-	{ pattern: /\bdienstag\b/i, getDate: () => nextTuesday(new Date()) },
-	{ pattern: /\bmittwoch\b/i, getDate: () => nextWednesday(new Date()) },
-	{ pattern: /\bdonnerstag\b/i, getDate: () => nextThursday(new Date()) },
-	{ pattern: /\bfreitag\b/i, getDate: () => nextFriday(new Date()) },
-	{ pattern: /\bsamstag\b/i, getDate: () => nextSaturday(new Date()) },
-	{ pattern: /\bsonntag\b/i, getDate: () => nextSunday(new Date()) },
+type DayFn = (date: Date) => Date;
+
+const NEXT_DAY_FNS: DayFn[] = [
+	nextMonday,
+	nextTuesday,
+	nextWednesday,
+	nextThursday,
+	nextFriday,
+	nextSaturday,
+	nextSunday,
 ];
 
-// Pattern for "in X Tagen"
-const IN_DAYS_PATTERN = /\bin\s*(\d+)\s*tage?n?\b/i;
+// Weekday names per locale (Monday-Sunday order)
+const WEEKDAY_NAMES: Record<ParserLocale, string[]> = {
+	de: ['montag', 'dienstag', 'mittwoch', 'donnerstag', 'freitag', 'samstag', 'sonntag'],
+	en: ['monday', 'tuesday', 'wednesday', 'thursday', 'friday', 'saturday', 'sunday'],
+	fr: ['lundi', 'mardi', 'mercredi', 'jeudi', 'vendredi', 'samedi', 'dimanche'],
+	es: ['lunes', 'martes', 'miércoles', 'jueves', 'viernes', 'sábado', 'domingo'],
+	it: ['lunedì', 'martedì', 'mercoledì', 'giovedì', 'venerdì', 'sabato', 'domenica'],
+};
 
-// Pattern for specific date (DD.MM. or DD.MM.YYYY)
-const SPECIFIC_DATE_PATTERN = /\b(\d{1,2})\.(\d{1,2})\.?(\d{2,4})?\b/;
+// Relative date keywords per locale
+interface RelativeDateWords {
+	today: string[];
+	tomorrow: string[];
+	dayAfterTomorrow: string[];
+	yesterday: string[];
+	dayBeforeYesterday: string[];
+	nextWeek: RegExp;
+	weekAfterNext: RegExp;
+	nextPrefix: RegExp;
+	thisPrefix: RegExp;
+}
+
+const RELATIVE_DATE_WORDS: Record<ParserLocale, RelativeDateWords> = {
+	de: {
+		today: ['heute'],
+		tomorrow: ['morgen'],
+		dayAfterTomorrow: ['übermorgen'],
+		yesterday: ['gestern'],
+		dayBeforeYesterday: ['vorgestern'],
+		nextWeek: /(?<!\p{L})nächste[nr]?\s*woche(?!\p{L})/iu,
+		weekAfterNext: /(?<!\p{L})über\s*nächste[nr]?\s*woche(?!\p{L})/iu,
+		nextPrefix: /(?<!\p{L})nächste[nr]?\s*/iu,
+		thisPrefix: /\bdiese[nr]?\s*/i,
+	},
+	en: {
+		today: ['today'],
+		tomorrow: ['tomorrow'],
+		dayAfterTomorrow: [],
+		yesterday: ['yesterday'],
+		dayBeforeYesterday: [],
+		nextWeek: /\bnext\s*week\b/i,
+		weekAfterNext: /\bweek\s*after\s*next\b/i,
+		nextPrefix: /\bnext\s*/i,
+		thisPrefix: /\bthis\s*/i,
+	},
+	fr: {
+		today: ["aujourd'hui", 'aujourdhui'],
+		tomorrow: ['demain'],
+		dayAfterTomorrow: ['après-demain', 'apres-demain'],
+		yesterday: ['hier'],
+		dayBeforeYesterday: ['avant-hier'],
+		nextWeek: /\bsemaine\s*prochaine\b/i,
+		weekAfterNext: /\bsemaine\s*d'?après\b/i,
+		nextPrefix: /\bprochain[e]?\s*/i,
+		thisPrefix: /\bce(?:tte?)?\s*/i,
+	},
+	es: {
+		today: ['hoy'],
+		tomorrow: ['mañana', 'manana'],
+		dayAfterTomorrow: ['pasado\\s*mañana', 'pasado\\s*manana'],
+		yesterday: ['ayer'],
+		dayBeforeYesterday: ['anteayer'],
+		nextWeek: /(?<!\p{L})próxima\s*semana(?!\p{L})/iu,
+		weekAfterNext: /(?<!\p{L})semana\s*después(?!\p{L})/iu,
+		nextPrefix: /(?<!\p{L})próxim[oa]\s*/iu,
+		thisPrefix: /\best[ea]\s*/i,
+	},
+	it: {
+		today: ['oggi'],
+		tomorrow: ['domani'],
+		dayAfterTomorrow: ['dopodomani'],
+		yesterday: ['ieri'],
+		dayBeforeYesterday: ["l'?altro\\s*ieri", 'avantieri'],
+		nextWeek: /\bprossima\s*settimana\b/i,
+		weekAfterNext: /\bsettimana\s*dopo\b/i,
+		nextPrefix: /\bprossim[oa]\s*/i,
+		thisPrefix: /\bquest[oa]\s*/i,
+	},
+};
+
+// "in X days" and "in X weeks" patterns per locale
+const IN_DAYS_PATTERNS: Record<ParserLocale, RegExp> = {
+	de: /\bin\s*(\d+)\s*tage?n?\b/i,
+	en: /\bin\s*(\d+)\s*days?\b/i,
+	fr: /\bdans\s*(\d+)\s*jours?\b/i,
+	es: /\ben\s*(\d+)\s*d[ií]as?\b/i,
+	it: /\btra\s*(\d+)\s*giorni?\b/i,
+};
+
+const IN_WEEKS_PATTERNS: Record<ParserLocale, RegExp> = {
+	de: /\bin\s*(\d+)\s*wochen?\b/i,
+	en: /\bin\s*(\d+)\s*weeks?\b/i,
+	fr: /\bdans\s*(\d+)\s*semaines?\b/i,
+	es: /\ben\s*(\d+)\s*semanas?\b/i,
+	it: /\btra\s*(\d+)\s*settimane?\b/i,
+};
+
+// Month names per locale (January=0)
+const MONTH_NAMES: Record<ParserLocale, string[]> = {
+	de: [
+		'januar',
+		'februar',
+		'märz',
+		'april',
+		'mai',
+		'juni',
+		'juli',
+		'august',
+		'september',
+		'oktober',
+		'november',
+		'dezember',
+	],
+	en: [
+		'january',
+		'february',
+		'march',
+		'april',
+		'may',
+		'june',
+		'july',
+		'august',
+		'september',
+		'october',
+		'november',
+		'december',
+	],
+	fr: [
+		'janvier',
+		'février',
+		'mars',
+		'avril',
+		'mai',
+		'juin',
+		'juillet',
+		'août',
+		'septembre',
+		'octobre',
+		'novembre',
+		'décembre',
+	],
+	es: [
+		'enero',
+		'febrero',
+		'marzo',
+		'abril',
+		'mayo',
+		'junio',
+		'julio',
+		'agosto',
+		'septiembre',
+		'octubre',
+		'noviembre',
+		'diciembre',
+	],
+	it: [
+		'gennaio',
+		'febbraio',
+		'marzo',
+		'aprile',
+		'maggio',
+		'giugno',
+		'luglio',
+		'agosto',
+		'settembre',
+		'ottobre',
+		'novembre',
+		'dicembre',
+	],
+};
+
+// Short month names (3 chars)
+const SHORT_MONTH_NAMES: Record<ParserLocale, string[]> = {
+	de: ['jan', 'feb', 'mär', 'apr', 'mai', 'jun', 'jul', 'aug', 'sep', 'okt', 'nov', 'dez'],
+	en: ['jan', 'feb', 'mar', 'apr', 'may', 'jun', 'jul', 'aug', 'sep', 'oct', 'nov', 'dec'],
+	fr: ['jan', 'fév', 'mar', 'avr', 'mai', 'jun', 'jul', 'aoû', 'sep', 'oct', 'nov', 'déc'],
+	es: ['ene', 'feb', 'mar', 'abr', 'may', 'jun', 'jul', 'ago', 'sep', 'oct', 'nov', 'dic'],
+	it: ['gen', 'feb', 'mar', 'apr', 'mag', 'giu', 'lug', 'ago', 'set', 'ott', 'nov', 'dic'],
+};
+
+// Time patterns per locale
+const TIME_PATTERNS: Record<ParserLocale, RegExp> = {
+	de: /\b(?:um\s*)?(\d{1,2})(?::(\d{2}))?\s*(?:uhr)?\b/i,
+	en: /\b(?:at\s*)?(\d{1,2})(?::(\d{2}))?\s*(?:o'?clock|am|pm)?\b/i,
+	fr: /\b(?:à\s*)?(\d{1,2})(?:[h:](\d{2}))?\s*(?:heures?)?\b/i,
+	es: /\b(?:a\s*las?\s*)?(\d{1,2})(?::(\d{2}))?\s*(?:horas?)?\b/i,
+	it: /\b(?:alle?\s*)?(\d{1,2})(?::(\d{2}))?\b/i,
+};
+
+// Preview formatting words
+const PREVIEW_WORDS: Record<ParserLocale, { today: string; tomorrow: string; locale: string }> = {
+	de: { today: 'Heute', tomorrow: 'Morgen', locale: 'de-DE' },
+	en: { today: 'Today', tomorrow: 'Tomorrow', locale: 'en-US' },
+	fr: { today: "Aujourd'hui", tomorrow: 'Demain', locale: 'fr-FR' },
+	es: { today: 'Hoy', tomorrow: 'Mañana', locale: 'es-ES' },
+	it: { today: 'Oggi', tomorrow: 'Domani', locale: 'it-IT' },
+};
+
+// ============================================================================
+// Fuzzy Matching Utilities
+// ============================================================================
+
+/**
+ * Simple Levenshtein distance (for short words only)
+ */
+function levenshtein(a: string, b: string): number {
+	const m = a.length;
+	const n = b.length;
+	const dp: number[][] = Array.from({ length: m + 1 }, () => Array(n + 1).fill(0));
+
+	for (let i = 0; i <= m; i++) dp[i][0] = i;
+	for (let j = 0; j <= n; j++) dp[0][j] = j;
+
+	for (let i = 1; i <= m; i++) {
+		for (let j = 1; j <= n; j++) {
+			dp[i][j] = Math.min(
+				dp[i - 1][j] + 1,
+				dp[i][j - 1] + 1,
+				dp[i - 1][j - 1] + (a[i - 1] === b[j - 1] ? 0 : 1)
+			);
+		}
+	}
+	return dp[m][n];
+}
+
+// Keywords that should support fuzzy matching (max distance 1-2 depending on length)
+const FUZZY_DATE_WORDS: Record<ParserLocale, string[]> = {
+	de: [
+		'heute',
+		'morgen',
+		'übermorgen',
+		'montag',
+		'dienstag',
+		'mittwoch',
+		'donnerstag',
+		'freitag',
+		'samstag',
+		'sonntag',
+	],
+	en: [
+		'today',
+		'tomorrow',
+		'monday',
+		'tuesday',
+		'wednesday',
+		'thursday',
+		'friday',
+		'saturday',
+		'sunday',
+	],
+	fr: ['demain', 'lundi', 'mardi', 'mercredi', 'jeudi', 'vendredi', 'samedi', 'dimanche'],
+	es: ['hoy', 'lunes', 'martes', 'jueves', 'viernes'],
+	it: ['oggi', 'domani'],
+};
+
+/**
+ * Try fuzzy matching a word against known date keywords.
+ * Returns the canonical keyword if a close match is found, undefined otherwise.
+ * Max distance: 1 for words <= 5 chars, 2 for longer words.
+ */
+export function fuzzyMatchDateKeyword(
+	word: string,
+	locale: ParserLocale = 'de'
+): string | undefined {
+	const keywords = FUZZY_DATE_WORDS[locale];
+	if (!keywords) return undefined;
+
+	const lower = word.toLowerCase();
+	const maxDist = lower.length <= 5 ? 1 : 2;
+
+	let bestMatch: string | undefined;
+	let bestDist = Infinity;
+
+	for (const keyword of keywords) {
+		// Skip if length difference is too large
+		if (Math.abs(lower.length - keyword.length) > maxDist) continue;
+
+		const dist = levenshtein(lower, keyword);
+		if (dist <= maxDist && dist < bestDist) {
+			bestDist = dist;
+			bestMatch = keyword;
+		}
+	}
+
+	return bestMatch;
+}
+
+// ============================================================================
+// Pattern Builder
+// ============================================================================
+
+// Word boundary that works with accented characters (lunedì, mañana, etc.)
+// Standard \b doesn't treat accented chars as word chars.
+// We use Unicode-aware regex with lookbehind/lookahead.
+function wb(word: string): string {
+	// Use negative lookbehind/lookahead for word-like chars including accented ones
+	return `(?<![\\p{L}\\p{N}])${word}(?![\\p{L}\\p{N}])`;
+}
+
+function buildDatePatterns(locale: ParserLocale): DatePattern[] {
+	const words = RELATIVE_DATE_WORDS[locale];
+	const weekdays = WEEKDAY_NAMES[locale];
+	const patterns: DatePattern[] = [];
+
+	// Today
+	for (const word of words.today) {
+		patterns.push({ pattern: new RegExp(wb(word), 'iu'), getDate: () => new Date() });
+	}
+
+	// Tomorrow
+	for (const word of words.tomorrow) {
+		patterns.push({
+			pattern: new RegExp(wb(word), 'iu'),
+			getDate: () => addDays(new Date(), 1),
+		});
+	}
+
+	// Day after tomorrow
+	for (const word of words.dayAfterTomorrow) {
+		patterns.push({
+			pattern: new RegExp(wb(word), 'iu'),
+			getDate: () => addDays(new Date(), 2),
+		});
+	}
+
+	// Yesterday
+	for (const word of words.yesterday) {
+		patterns.push({
+			pattern: new RegExp(wb(word), 'iu'),
+			getDate: () => addDays(new Date(), -1),
+		});
+	}
+
+	// Day before yesterday
+	for (const word of words.dayBeforeYesterday) {
+		patterns.push({
+			pattern: new RegExp(wb(word), 'iu'),
+			getDate: () => addDays(new Date(), -2),
+		});
+	}
+
+	// Week after next (must come before "next week")
+	patterns.push({ pattern: words.weekAfterNext, getDate: () => addDays(new Date(), 14) });
+
+	// Next week
+	patterns.push({ pattern: words.nextWeek, getDate: () => addDays(new Date(), 7) });
+
+	// "this <weekday>" patterns - gets the day in the current week
+	// If already past, still returns this week's day (for logging retroactively)
+	for (let i = 0; i < weekdays.length; i++) {
+		const day = weekdays[i];
+		const targetDayOfWeek = [1, 2, 3, 4, 5, 6, 0][i]; // Mon=1..Sun=0
+
+		patterns.push({
+			pattern: new RegExp(`${words.thisPrefix.source}${day}(?![\\p{L}\\p{N}])`, 'iu'),
+			getDate: () => {
+				const now = new Date();
+				const currentDay = now.getDay();
+				if (currentDay === targetDayOfWeek) return now;
+				// If the target day is earlier in the week, use previous, otherwise next
+				const thisWeekStart = startOfWeek(now, { weekStartsOn: 1 });
+				const diff = targetDayOfWeek === 0 ? 6 : targetDayOfWeek - 1; // days from Monday
+				return addDays(thisWeekStart, diff);
+			},
+		});
+	}
+
+	// "next <weekday>" patterns
+	for (let i = 0; i < weekdays.length; i++) {
+		const dayFn = NEXT_DAY_FNS[i];
+		const day = weekdays[i];
+		patterns.push({
+			pattern: new RegExp(`${words.nextPrefix.source}${day}(?![\\p{L}\\p{N}])`, 'iu'),
+			getDate: () => dayFn(new Date()),
+		});
+	}
+
+	// Plain weekday names (implies "next")
+	for (let i = 0; i < weekdays.length; i++) {
+		const dayFn = NEXT_DAY_FNS[i];
+		const day = weekdays[i];
+		patterns.push({
+			pattern: new RegExp(wb(day), 'iu'),
+			getDate: () => dayFn(new Date()),
+		});
+	}
+
+	// Month names: "im März", "in January", "en février"
+	const months = MONTH_NAMES[locale];
+	const monthPrepositions: Record<ParserLocale, string> = {
+		de: '(?:im|in)\\s+',
+		en: '(?:in)\\s+',
+		fr: '(?:en)\\s+',
+		es: '(?:en)\\s+',
+		it: '(?:in|a)\\s+',
+	};
+
+	for (let i = 0; i < months.length; i++) {
+		const monthIndex = i;
+		const monthName = months[i];
+		// "im März" / "in January"
+		patterns.push({
+			pattern: new RegExp(`\\b${monthPrepositions[locale]}${monthName}\\b`, 'iu'),
+			getDate: () => {
+				const now = new Date();
+				let year = now.getFullYear();
+				// If month already passed, use next year
+				if (monthIndex < now.getMonth()) year++;
+				return new Date(year, monthIndex, 1);
+			},
+		});
+	}
+
+	return patterns;
+}
+
+// Cache built patterns per locale
+const datePatternCache = new Map<ParserLocale, DatePattern[]>();
+
+function getDatePatterns(locale: ParserLocale): DatePattern[] {
+	let patterns = datePatternCache.get(locale);
+	if (!patterns) {
+		patterns = buildDatePatterns(locale);
+		datePatternCache.set(locale, patterns);
+	}
+	return patterns;
+}
+
+// ============================================================================
+// Specific date pattern (DD.MM. or DD.MM.YYYY or MM/DD/YYYY)
+// ============================================================================
+
+// DD.MM. or DD.MM.YYYY (European)
+const EU_DATE_PATTERN = /\b(\d{1,2})\.(\d{1,2})\.?(\d{2,4})?\b/;
+// MM/DD/YYYY or MM/DD (US)
+const US_DATE_PATTERN = /\b(\d{1,2})\/(\d{1,2})(?:\/(\d{2,4}))?\b/;
+
+function getSpecificDatePattern(locale: ParserLocale): {
+	pattern: RegExp;
+	parse: (match: RegExpMatchArray) => Date;
+} {
+	if (locale === 'en') {
+		return {
+			pattern: US_DATE_PATTERN,
+			parse: (match) => {
+				const month = parseInt(match[1], 10) - 1;
+				const day = parseInt(match[2], 10);
+				const year = match[3]
+					? parseInt(match[3], 10) < 100
+						? 2000 + parseInt(match[3], 10)
+						: parseInt(match[3], 10)
+					: new Date().getFullYear();
+				return new Date(year, month, day);
+			},
+		};
+	}
+	// European format (DE, FR, ES, IT)
+	return {
+		pattern: EU_DATE_PATTERN,
+		parse: (match) => {
+			const day = parseInt(match[1], 10);
+			const month = parseInt(match[2], 10) - 1;
+			const year = match[3]
+				? parseInt(match[3], 10) < 100
+					? 2000 + parseInt(match[3], 10)
+					: parseInt(match[3], 10)
+				: new Date().getFullYear();
+			return new Date(year, month, day);
+		},
+	};
+}
+
+// ============================================================================
+// Date Extraction
+// ============================================================================
 
 /**
  * Extract date from text
  */
-export function extractDate(text: string): ExtractResult<Date> {
+export function extractDate(text: string, locale: ParserLocale = 'de'): ExtractResult<Date> {
 	let remaining = text;
-	let date: Date | undefined;
 
-	// Try "in X Tagen" pattern first
-	const inDaysMatch = remaining.match(IN_DAYS_PATTERN);
+	// Try "in X weeks" pattern first (before "in X days" to avoid partial match)
+	const inWeeksPattern = IN_WEEKS_PATTERNS[locale];
+	const inWeeksMatch = remaining.match(inWeeksPattern);
+	if (inWeeksMatch) {
+		const weeks = parseInt(inWeeksMatch[1], 10);
+		const date = addWeeks(new Date(), weeks);
+		remaining = remaining.replace(inWeeksPattern, '').trim();
+		return { value: date, remaining };
+	}
+
+	// Try "in X days" pattern
+	const inDaysPattern = IN_DAYS_PATTERNS[locale];
+	const inDaysMatch = remaining.match(inDaysPattern);
 	if (inDaysMatch) {
 		const days = parseInt(inDaysMatch[1], 10);
-		date = addDays(new Date(), days);
-		remaining = remaining.replace(IN_DAYS_PATTERN, '').trim();
+		const date = addDays(new Date(), days);
+		remaining = remaining.replace(inDaysPattern, '').trim();
 		return { value: date, remaining };
 	}
 
-	// Try specific date (DD.MM. or DD.MM.YYYY)
-	const specificDateMatch = remaining.match(SPECIFIC_DATE_PATTERN);
+	// Try ordinal + month: "5. März", "3rd of May", "le 5 mars"
+	const months = MONTH_NAMES[locale];
+	const shortMonthsList = SHORT_MONTH_NAMES[locale];
+	const allMonths = [...months, ...shortMonthsList];
+	const monthPattern = allMonths.join('|');
+
+	// Ordinal patterns per locale
+	const ordinalPatterns: Record<ParserLocale, RegExp> = {
+		de: new RegExp(`\\b(\\d{1,2})\\.\\s*(${monthPattern})\\b`, 'iu'),
+		en: new RegExp(`\\b(\\d{1,2})(?:st|nd|rd|th)?\\s+(?:of\\s+)?(${monthPattern})\\b`, 'iu'),
+		fr: new RegExp(`\\b(?:le\\s+)?(\\d{1,2})(?:er|e|ème)?\\s+(${monthPattern})\\b`, 'iu'),
+		es: new RegExp(`\\b(?:el\\s+)?(\\d{1,2})\\s+(?:de\\s+)?(${monthPattern})\\b`, 'iu'),
+		it: new RegExp(`\\b(?:il\\s+)?(\\d{1,2})\\s+(${monthPattern})\\b`, 'iu'),
+	};
+
+	const ordinalMatch = remaining.match(ordinalPatterns[locale]);
+	if (ordinalMatch) {
+		const day = parseInt(ordinalMatch[1], 10);
+		const monthStr = ordinalMatch[2].toLowerCase();
+		let monthIndex = months.findIndex((m) => m.toLowerCase() === monthStr);
+		if (monthIndex === -1) {
+			monthIndex = shortMonthsList.findIndex((m) => m.toLowerCase() === monthStr);
+		}
+		if (monthIndex >= 0 && day >= 1 && day <= 31) {
+			const now = new Date();
+			let year = now.getFullYear();
+			const candidate = new Date(year, monthIndex, day);
+			if (isBefore(candidate, now)) year++;
+			remaining = remaining.replace(ordinalPatterns[locale], '').trim();
+			return { value: new Date(year, monthIndex, day), remaining };
+		}
+	}
+
+	// Try specific date (DD.MM. or MM/DD)
+	const { pattern: specificPattern, parse: parseSpecific } = getSpecificDatePattern(locale);
+	const specificDateMatch = remaining.match(specificPattern);
 	if (specificDateMatch) {
-		const day = parseInt(specificDateMatch[1], 10);
-		const month = parseInt(specificDateMatch[2], 10) - 1;
-		const year = specificDateMatch[3]
-			? parseInt(specificDateMatch[3], 10) < 100
-				? 2000 + parseInt(specificDateMatch[3], 10)
-				: parseInt(specificDateMatch[3], 10)
-			: new Date().getFullYear();
-
-		date = new Date(year, month, day);
-		remaining = remaining.replace(SPECIFIC_DATE_PATTERN, '').trim();
+		const date = parseSpecific(specificDateMatch);
+		remaining = remaining.replace(specificPattern, '').trim();
 		return { value: date, remaining };
 	}
 
-	// Try relative date patterns
-	for (const { pattern, getDate } of DATE_PATTERNS) {
+	// Try relative date patterns (exact match)
+	const patterns = getDatePatterns(locale);
+	for (const { pattern, getDate } of patterns) {
 		if (pattern.test(remaining)) {
-			date = getDate();
+			const date = getDate();
 			remaining = remaining.replace(pattern, '').trim();
 			return { value: date, remaining };
 		}
 	}
 
+	// Fuzzy match: try each word against known date keywords
+	const words = remaining.split(/\s+/);
+	for (const word of words) {
+		if (word.length < 3) continue; // Skip very short words
+		const matched = fuzzyMatchDateKeyword(word, locale);
+		if (matched) {
+			// Re-run extraction with the corrected keyword
+			const corrected = remaining.replace(
+				new RegExp(word.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'), 'i'),
+				matched
+			);
+			const retryResult = extractDate(corrected, locale);
+			if (retryResult.value) {
+				return retryResult;
+			}
+		}
+	}
+
 	return { value: undefined, remaining };
 }
 
 // ============================================================================
-// Time Extraction
+// Date Range Extraction
 // ============================================================================
 
-// Pattern for time (um 14 Uhr, 14:00, etc.)
-const TIME_PATTERN = /\b(?:um\s*)?(\d{1,2})(?::(\d{2}))?\s*(?:uhr)?\b/i;
+export interface DateRange {
+	start: Date;
+	end: Date;
+}
+
+// "15.-17. März", "15-17 March", "Mon-Fri"
+const EU_DATE_RANGE_PATTERN = /\b(\d{1,2})\.\s*[-–]\s*(\d{1,2})\.\s*(\d{1,2})?\.\s*/;
+
+/**
+ * Extract a date range (e.g., "15.-17.3.", "15.-17. März")
+ */
+export function extractDateRange(
+	text: string,
+	locale: ParserLocale = 'de'
+): ExtractResult<DateRange> {
+	// Try "DD.-DD.MM." or "DD.-DD. MonthName"
+	const months = MONTH_NAMES[locale];
+	const monthPattern = months.join('|');
+
+	// "15.-17. März" / "15-17 March"
+	const withMonthName = new RegExp(
+		`\\b(\\d{1,2})\\.?\\s*[-–]\\s*(\\d{1,2})\\.?\\s+(${monthPattern})\\b`,
+		'iu'
+	);
+	const match = text.match(withMonthName);
+	if (match) {
+		const startDay = parseInt(match[1]);
+		const endDay = parseInt(match[2]);
+		const monthStr = match[3].toLowerCase();
+		const monthIndex = months.findIndex((m) => m.toLowerCase() === monthStr);
+		if (monthIndex >= 0 && startDay >= 1 && endDay >= 1) {
+			const year = new Date().getFullYear();
+			return {
+				value: {
+					start: new Date(year, monthIndex, startDay),
+					end: new Date(year, monthIndex, endDay),
+				},
+				remaining: text.replace(withMonthName, '').trim(),
+			};
+		}
+	}
+
+	// "15.-17.3." (EU numeric format)
+	const euMatch = text.match(EU_DATE_RANGE_PATTERN);
+	if (euMatch && euMatch[3]) {
+		const startDay = parseInt(euMatch[1]);
+		const endDay = parseInt(euMatch[2]);
+		const month = parseInt(euMatch[3]) - 1;
+		const year = new Date().getFullYear();
+		if (startDay >= 1 && endDay >= 1 && month >= 0 && month <= 11) {
+			return {
+				value: {
+					start: new Date(year, month, startDay),
+					end: new Date(year, month, endDay),
+				},
+				remaining: text.replace(EU_DATE_RANGE_PATTERN, '').trim(),
+			};
+		}
+	}
+
+	return { value: undefined, remaining: text };
+}
+
+// ============================================================================
+// Relative Time Extraction ("in 2 Stunden", "in 30 Minuten")
+// ============================================================================
+
+interface RelativeTimePattern {
+	pattern: RegExp;
+	getDate: (match: RegExpMatchArray) => Date;
+}
+
+const RELATIVE_TIME_PATTERNS: Record<ParserLocale, RelativeTimePattern[]> = {
+	de: [
+		{ pattern: /\bin\s+einer?\s+halben\s+stunde\b/i, getDate: () => addMinutes(new Date(), 30) },
+		{
+			pattern: /\bin\s+(\d+)\s+stunde[n]?\b/i,
+			getDate: (m) => addHours(new Date(), parseInt(m[1])),
+		},
+		{
+			pattern: /\bin\s+(\d+)\s+minute[n]?\b/i,
+			getDate: (m) => addMinutes(new Date(), parseInt(m[1])),
+		},
+	],
+	en: [
+		{ pattern: /\bin\s+half\s+an?\s+hour\b/i, getDate: () => addMinutes(new Date(), 30) },
+		{
+			pattern: /\bin\s+(\d+)\s+hours?\b/i,
+			getDate: (m) => addHours(new Date(), parseInt(m[1])),
+		},
+		{
+			pattern: /\bin\s+(\d+)\s+minutes?\b/i,
+			getDate: (m) => addMinutes(new Date(), parseInt(m[1])),
+		},
+	],
+	fr: [
+		{ pattern: /\bdans\s+une?\s+demi[e]?\s+heure\b/i, getDate: () => addMinutes(new Date(), 30) },
+		{
+			pattern: /\bdans\s+(\d+)\s+heures?\b/i,
+			getDate: (m) => addHours(new Date(), parseInt(m[1])),
+		},
+		{
+			pattern: /\bdans\s+(\d+)\s+minutes?\b/i,
+			getDate: (m) => addMinutes(new Date(), parseInt(m[1])),
+		},
+	],
+	es: [
+		{ pattern: /\ben\s+media\s+hora\b/i, getDate: () => addMinutes(new Date(), 30) },
+		{
+			pattern: /\ben\s+(\d+)\s+horas?\b/i,
+			getDate: (m) => addHours(new Date(), parseInt(m[1])),
+		},
+		{
+			pattern: /\ben\s+(\d+)\s+minutos?\b/i,
+			getDate: (m) => addMinutes(new Date(), parseInt(m[1])),
+		},
+	],
+	it: [
+		{ pattern: /\btra\s+mezz'?ora\b/i, getDate: () => addMinutes(new Date(), 30) },
+		{
+			pattern: /\btra\s+(\d+)\s+or[ea]\b/i,
+			getDate: (m) => addHours(new Date(), parseInt(m[1])),
+		},
+		{
+			pattern: /\btra\s+(\d+)\s+minut[io]\b/i,
+			getDate: (m) => addMinutes(new Date(), parseInt(m[1])),
+		},
+	],
+};
+
+/**
+ * Extract relative time expressions ("in 2 hours", "in 30 minutes")
+ * Returns a full Date since relative time implies date + time
+ */
+export function extractRelativeTime(
+	text: string,
+	locale: ParserLocale = 'de'
+): ExtractResult<Date> {
+	const patterns = RELATIVE_TIME_PATTERNS[locale];
+	for (const { pattern, getDate } of patterns) {
+		const match = text.match(pattern);
+		if (match) {
+			return {
+				value: getDate(match),
+				remaining: text.replace(pattern, '').trim(),
+			};
+		}
+	}
+	return { value: undefined, remaining: text };
+}
+
+// ============================================================================
+// Time Extraction
+// ============================================================================
 
 /**
  * Extract time from text
  */
-export function extractTime(text: string): ExtractResult<{ hours: number; minutes: number }> {
-	const match = text.match(TIME_PATTERN);
+export function extractTime(
+	text: string,
+	locale: ParserLocale = 'de'
+): ExtractResult<{ hours: number; minutes: number }> {
+	const timePattern = TIME_PATTERNS[locale];
+	const match = text.match(timePattern);
 
 	if (match) {
-		const hours = parseInt(match[1], 10);
+		let hours = parseInt(match[1], 10);
 		const minutes = match[2] ? parseInt(match[2], 10) : 0;
 
+		// Handle AM/PM for English
+		if (locale === 'en') {
+			const fullMatch = match[0].toLowerCase();
+			if (fullMatch.includes('pm') && hours < 12) hours += 12;
+			if (fullMatch.includes('am') && hours === 12) hours = 0;
+		}
+
 		// Validate time
 		if (hours >= 0 && hours <= 23 && minutes >= 0 && minutes <= 59) {
-			const remaining = text.replace(TIME_PATTERN, '').trim();
+			const remaining = text.replace(timePattern, '').trim();
 			return { value: { hours, minutes }, remaining };
 		}
 	}
@@ -138,6 +828,61 @@ export function extractTime(text: string): ExtractResult<{ hours: number; minute
 	return { value: undefined, remaining: text };
 }
 
+// ============================================================================
+// Timezone Extraction
+// ============================================================================
+
+// Common timezone abbreviations mapped to IANA timezone identifiers
+const TIMEZONE_MAP: Record<string, string> = {
+	// European
+	CET: 'Europe/Berlin',
+	CEST: 'Europe/Berlin',
+	MET: 'Europe/Berlin',
+	MEST: 'Europe/Berlin',
+	WET: 'Europe/London',
+	WEST: 'Europe/London',
+	EET: 'Europe/Athens',
+	EEST: 'Europe/Athens',
+	GMT: 'Europe/London',
+	// US
+	EST: 'America/New_York',
+	EDT: 'America/New_York',
+	CST: 'America/Chicago',
+	CDT: 'America/Chicago',
+	MST: 'America/Denver',
+	MDT: 'America/Denver',
+	PST: 'America/Los_Angeles',
+	PDT: 'America/Los_Angeles',
+	// Asia/Pacific
+	JST: 'Asia/Tokyo',
+	KST: 'Asia/Seoul',
+	IST: 'Asia/Kolkata',
+	AEST: 'Australia/Sydney',
+	// Universal
+	UTC: 'UTC',
+};
+
+const TIMEZONE_ABBREVS = Object.keys(TIMEZONE_MAP).join('|');
+const TIMEZONE_PATTERN = new RegExp(`\\b(${TIMEZONE_ABBREVS})\\b`);
+
+/**
+ * Extract timezone abbreviation from text
+ * Returns the IANA timezone identifier
+ */
+export function extractTimezone(text: string): ExtractResult<string> {
+	const match = text.match(TIMEZONE_PATTERN);
+	if (match) {
+		const tz = TIMEZONE_MAP[match[1].toUpperCase()];
+		if (tz) {
+			return {
+				value: tz,
+				remaining: text.replace(TIMEZONE_PATTERN, '').trim(),
+			};
+		}
+	}
+	return { value: undefined, remaining: text };
+}
+
 // ============================================================================
 // Tag Extraction
 // ============================================================================
@@ -163,7 +908,7 @@ export function extractTags(text: string): ExtractResult<string[]> {
 // ============================================================================
 
 /**
- * Extract @reference from text
+ * Extract @reference from text (single)
  */
 export function extractAtReference(text: string): ExtractResult<string> {
 	const match = text.match(/@(\S+)/);
@@ -176,6 +921,22 @@ export function extractAtReference(text: string): ExtractResult<string> {
 	return { value: undefined, remaining: text };
 }
 
+/**
+ * Extract all @references from text
+ */
+export function extractAtReferences(text: string): ExtractResult<string[]> {
+	const refs: string[] = [];
+	const refRegex = /@(\S+)/g;
+	let match;
+
+	while ((match = refRegex.exec(text)) !== null) {
+		refs.push(match[1]);
+	}
+
+	const remaining = text.replace(/@\S+/g, '').trim();
+	return { value: refs.length > 0 ? refs : undefined, remaining };
+}
+
 // ============================================================================
 // Combined Date + Time
 // ============================================================================
@@ -203,18 +964,19 @@ export function combineDateAndTime(
 /**
  * Format date for preview display
  */
-export function formatDatePreview(date: Date): string {
+export function formatDatePreview(date: Date, locale: ParserLocale = 'de'): string {
 	const now = new Date();
 	const tomorrow = addDays(now, 1);
+	const words = PREVIEW_WORDS[locale];
 
 	if (date.toDateString() === now.toDateString()) {
-		return 'Heute';
+		return words.today;
 	}
 	if (date.toDateString() === tomorrow.toDateString()) {
-		return 'Morgen';
+		return words.tomorrow;
 	}
 
-	return date.toLocaleDateString('de-DE', {
+	return date.toLocaleDateString(words.locale, {
 		weekday: 'short',
 		day: 'numeric',
 		month: 'short',
@@ -233,11 +995,12 @@ export function formatTimePreview(time: { hours: number; minutes: number }): str
  */
 export function formatDateTimePreview(
 	date?: Date,
-	time?: { hours: number; minutes: number }
+	time?: { hours: number; minutes: number },
+	locale: ParserLocale = 'de'
 ): string {
 	if (!date) return '';
 
-	let result = formatDatePreview(date);
+	let result = formatDatePreview(date, locale);
 
 	if (time) {
 		result += ` ${formatTimePreview(time)}`;
@@ -246,6 +1009,112 @@ export function formatDateTimePreview(
 	return result;
 }
 
+// ============================================================================
+// Recurrence Extraction
+// ============================================================================
+
+interface RecurrencePattern {
+	pattern: RegExp;
+	rrule: string;
+}
+
+const RECURRENCE_PATTERNS: Record<ParserLocale, RecurrencePattern[]> = {
+	de: [
+		{ pattern: /\bjeden\s+tag\b/i, rrule: 'FREQ=DAILY' },
+		{ pattern: /\btäglich\b/i, rrule: 'FREQ=DAILY' },
+		{ pattern: /\bjede\s+woche\b/i, rrule: 'FREQ=WEEKLY' },
+		{ pattern: /\bwöchentlich\b/i, rrule: 'FREQ=WEEKLY' },
+		{ pattern: /\bjeden\s+monat\b/i, rrule: 'FREQ=MONTHLY' },
+		{ pattern: /\bmonatlich\b/i, rrule: 'FREQ=MONTHLY' },
+		{ pattern: /\bjedes\s+jahr\b/i, rrule: 'FREQ=YEARLY' },
+		{ pattern: /\bjährlich\b/i, rrule: 'FREQ=YEARLY' },
+		{ pattern: /\bjeden\s+montag\b/i, rrule: 'FREQ=WEEKLY;BYDAY=MO' },
+		{ pattern: /\bjeden\s+dienstag\b/i, rrule: 'FREQ=WEEKLY;BYDAY=TU' },
+		{ pattern: /\bjeden\s+mittwoch\b/i, rrule: 'FREQ=WEEKLY;BYDAY=WE' },
+		{ pattern: /\bjeden\s+donnerstag\b/i, rrule: 'FREQ=WEEKLY;BYDAY=TH' },
+		{ pattern: /\bjeden\s+freitag\b/i, rrule: 'FREQ=WEEKLY;BYDAY=FR' },
+		{ pattern: /\bjeden\s+samstag\b/i, rrule: 'FREQ=WEEKLY;BYDAY=SA' },
+		{ pattern: /\bjeden\s+sonntag\b/i, rrule: 'FREQ=WEEKLY;BYDAY=SU' },
+		{ pattern: /\balle\s+(\d+)\s+tage\b/i, rrule: 'FREQ=DAILY;INTERVAL=$1' },
+		{ pattern: /\balle\s+(\d+)\s+wochen\b/i, rrule: 'FREQ=WEEKLY;INTERVAL=$1' },
+	],
+	en: [
+		{ pattern: /\bevery\s+day\b/i, rrule: 'FREQ=DAILY' },
+		{ pattern: /\bdaily\b/i, rrule: 'FREQ=DAILY' },
+		{ pattern: /\bevery\s+week\b/i, rrule: 'FREQ=WEEKLY' },
+		{ pattern: /\bweekly\b/i, rrule: 'FREQ=WEEKLY' },
+		{ pattern: /\bevery\s+month\b/i, rrule: 'FREQ=MONTHLY' },
+		{ pattern: /\bmonthly\b/i, rrule: 'FREQ=MONTHLY' },
+		{ pattern: /\bevery\s+year\b/i, rrule: 'FREQ=YEARLY' },
+		{ pattern: /\byearly\b/i, rrule: 'FREQ=YEARLY' },
+		{ pattern: /\bevery\s+monday\b/i, rrule: 'FREQ=WEEKLY;BYDAY=MO' },
+		{ pattern: /\bevery\s+tuesday\b/i, rrule: 'FREQ=WEEKLY;BYDAY=TU' },
+		{ pattern: /\bevery\s+wednesday\b/i, rrule: 'FREQ=WEEKLY;BYDAY=WE' },
+		{ pattern: /\bevery\s+thursday\b/i, rrule: 'FREQ=WEEKLY;BYDAY=TH' },
+		{ pattern: /\bevery\s+friday\b/i, rrule: 'FREQ=WEEKLY;BYDAY=FR' },
+		{ pattern: /\bevery\s+saturday\b/i, rrule: 'FREQ=WEEKLY;BYDAY=SA' },
+		{ pattern: /\bevery\s+sunday\b/i, rrule: 'FREQ=WEEKLY;BYDAY=SU' },
+		{ pattern: /\bevery\s+(\d+)\s+days\b/i, rrule: 'FREQ=DAILY;INTERVAL=$1' },
+		{ pattern: /\bevery\s+(\d+)\s+weeks\b/i, rrule: 'FREQ=WEEKLY;INTERVAL=$1' },
+	],
+	fr: [
+		{ pattern: /\btous\s+les\s+jours\b/i, rrule: 'FREQ=DAILY' },
+		{ pattern: /\bquotidien\b/i, rrule: 'FREQ=DAILY' },
+		{ pattern: /\bchaque\s+semaine\b/i, rrule: 'FREQ=WEEKLY' },
+		{ pattern: /\bhebdomadaire\b/i, rrule: 'FREQ=WEEKLY' },
+		{ pattern: /\bchaque\s+mois\b/i, rrule: 'FREQ=MONTHLY' },
+		{ pattern: /\bmensuel\b/i, rrule: 'FREQ=MONTHLY' },
+		{ pattern: /\bchaque\s+année\b/i, rrule: 'FREQ=YEARLY' },
+		{ pattern: /\bannuel\b/i, rrule: 'FREQ=YEARLY' },
+		{ pattern: /\bchaque\s+lundi\b/i, rrule: 'FREQ=WEEKLY;BYDAY=MO' },
+		{ pattern: /\bchaque\s+mardi\b/i, rrule: 'FREQ=WEEKLY;BYDAY=TU' },
+		{ pattern: /\bchaque\s+mercredi\b/i, rrule: 'FREQ=WEEKLY;BYDAY=WE' },
+		{ pattern: /\bchaque\s+jeudi\b/i, rrule: 'FREQ=WEEKLY;BYDAY=TH' },
+		{ pattern: /\bchaque\s+vendredi\b/i, rrule: 'FREQ=WEEKLY;BYDAY=FR' },
+	],
+	es: [
+		{ pattern: /\btodos\s+los\s+d[ií]as\b/i, rrule: 'FREQ=DAILY' },
+		{ pattern: /\bdiario\b/i, rrule: 'FREQ=DAILY' },
+		{ pattern: /\bcada\s+semana\b/i, rrule: 'FREQ=WEEKLY' },
+		{ pattern: /\bsemanal\b/i, rrule: 'FREQ=WEEKLY' },
+		{ pattern: /\bcada\s+mes\b/i, rrule: 'FREQ=MONTHLY' },
+		{ pattern: /\bmensual\b/i, rrule: 'FREQ=MONTHLY' },
+		{ pattern: /\bcada\s+año\b/i, rrule: 'FREQ=YEARLY' },
+		{ pattern: /\banual\b/i, rrule: 'FREQ=YEARLY' },
+		{ pattern: /\bcada\s+lunes\b/i, rrule: 'FREQ=WEEKLY;BYDAY=MO' },
+	],
+	it: [
+		{ pattern: /\bogni\s+giorno\b/i, rrule: 'FREQ=DAILY' },
+		{ pattern: /\bgiornaliero\b/i, rrule: 'FREQ=DAILY' },
+		{ pattern: /\bogni\s+settimana\b/i, rrule: 'FREQ=WEEKLY' },
+		{ pattern: /\bsettimanale\b/i, rrule: 'FREQ=WEEKLY' },
+		{ pattern: /\bogni\s+mese\b/i, rrule: 'FREQ=MONTHLY' },
+		{ pattern: /\bmensile\b/i, rrule: 'FREQ=MONTHLY' },
+		{ pattern: /\bogni\s+anno\b/i, rrule: 'FREQ=YEARLY' },
+		{ pattern: /\bannuale\b/i, rrule: 'FREQ=YEARLY' },
+	],
+};
+
+/**
+ * Extract recurrence rule from text, returns RFC 5545 RRULE string
+ */
+export function extractRecurrence(
+	text: string,
+	locale: ParserLocale = 'de'
+): ExtractResult<string> {
+	const patterns = RECURRENCE_PATTERNS[locale];
+	for (const { pattern, rrule } of patterns) {
+		const match = text.match(pattern);
+		if (match) {
+			// Replace $1 with captured group if present
+			const resolvedRrule = match[1] ? rrule.replace('$1', match[1]) : rrule;
+			const remaining = text.replace(pattern, '').trim();
+			return { value: resolvedRrule, remaining };
+		}
+	}
+	return { value: undefined, remaining: text };
+}
+
 // ============================================================================
 // Main Parser Function
 // ============================================================================
@@ -255,7 +1124,7 @@ export function formatDateTimePreview(
  *
  * App-specific parsers should call this first, then extract their own patterns.
  */
-export function parseBaseInput(input: string): BaseParsedInput {
+export function parseBaseInput(input: string, locale: ParserLocale = 'de'): BaseParsedInput {
 	let text = input.trim();
 	const rawInput = text;
 
@@ -265,12 +1134,12 @@ export function parseBaseInput(input: string): BaseParsedInput {
 	const tagNames = tagsResult.value || [];
 
 	// Extract date
-	const dateResult = extractDate(text);
+	const dateResult = extractDate(text, locale);
 	text = dateResult.remaining;
 	const date = dateResult.value;
 
 	// Extract time
-	const timeResult = extractTime(text);
+	const timeResult = extractTime(text, locale);
 	text = timeResult.remaining;
 	const time = timeResult.value;
 
@@ -280,12 +1149,23 @@ export function parseBaseInput(input: string): BaseParsedInput {
 	// Clean up multiple spaces
 	const title = text.replace(/\s+/g, ' ').trim();
 
+	// Calculate confidence: how much was extracted vs raw input
+	const hasExtractions = !!(finalDate || time || tagNames.length > 0);
+	let confidence = 1.0;
+	if (!hasExtractions && title === rawInput) {
+		confidence = 0.5; // Nothing was extracted - ambiguous
+	} else if (hasExtractions) {
+		// Check if the remaining title still looks clean
+		confidence = title.length > 0 ? 1.0 : 0.8;
+	}
+
 	return {
 		title,
 		date: finalDate,
 		time,
 		tagNames,
 		rawInput,
+		confidence,
 	};
 }
 
@@ -296,7 +1176,7 @@ export function parseBaseInput(input: string): BaseParsedInput {
 /**
  * Remove all recognized patterns from text to get clean title
  */
-export function cleanTitle(text: string): string {
+export function cleanTitle(text: string, locale: ParserLocale = 'de'): string {
 	let result = text;
 
 	// Remove tags
@@ -305,16 +1185,76 @@ export function cleanTitle(text: string): string {
 	// Remove @references
 	result = result.replace(/@\S+/g, '');
 
-	// Remove dates
-	result = result.replace(IN_DAYS_PATTERN, '');
-	result = result.replace(SPECIFIC_DATE_PATTERN, '');
-	for (const { pattern } of DATE_PATTERNS) {
+	// Remove "in X days"
+	result = result.replace(IN_DAYS_PATTERNS[locale], '');
+
+	// Remove specific dates
+	const { pattern: specificPattern } = getSpecificDatePattern(locale);
+	result = result.replace(specificPattern, '');
+
+	// Remove relative date patterns
+	for (const { pattern } of getDatePatterns(locale)) {
 		result = result.replace(pattern, '');
 	}
 
 	// Remove time
-	result = result.replace(TIME_PATTERN, '');
+	result = result.replace(TIME_PATTERNS[locale], '');
 
 	// Clean up
 	return result.replace(/\s+/g, ' ').trim();
 }
+
+// ============================================================================
+// Parser Compose Helper
+// ============================================================================
+
+/**
+ * Extraction step definition for compose helper
+ */
+export interface ExtractionStep<T> {
+	/** Name of this extraction (used as key in result) */
+	name: string;
+	/** Extract function: takes text, returns value and remaining text */
+	extract: (text: string) => { value: T | undefined; remaining: string };
+}
+
+/**
+ * Create an app-specific parser from a list of extraction steps.
+ * Runs base parser first (date, time, tags), then custom steps.
+ *
+ * @example
+ * ```ts
+ * const { parse } = createAppParser('de', [
+ *   { name: 'priority', extract: extractPriority },
+ *   { name: 'project', extract: (t) => extractAtReference(t) },
+ * ]);
+ * const result = parse('Task morgen @Arbeit !!!');
+ * // result.base = { title, date, time, tagNames, ... }
+ * // result.extractions = { priority: 'urgent', project: 'Arbeit' }
+ * ```
+ */
+export function createAppParser<T extends Record<string, unknown>>(
+	locale: ParserLocale,
+	steps: ExtractionStep<unknown>[]
+): {
+	parse: (input: string) => { base: BaseParsedInput; extractions: T };
+} {
+	return {
+		parse(input: string) {
+			let text = input.trim();
+			const extractions: Record<string, unknown> = {};
+
+			// Run custom extraction steps first (before base parser)
+			for (const step of steps) {
+				const result = step.extract(text);
+				extractions[step.name] = result.value;
+				text = result.remaining;
+			}
+
+			// Run base parser on remaining text
+			const base = parseBaseInput(text, locale);
+
+			return { base, extractions: extractions as T };
+		},
+	};
+}
diff --git a/packages/shared-utils/src/parsers/index.ts b/packages/shared-utils/src/parsers/index.ts
index b209804ef..8415f16df 100644
--- a/packages/shared-utils/src/parsers/index.ts
+++ b/packages/shared-utils/src/parsers/index.ts
@@ -2,17 +2,26 @@
  * Natural Language Parsers
  *
  * Base parser with common patterns, extended by app-specific parsers.
+ * Supports locales: de, en, fr, es, it
  */
 
 export {
 	// Types
 	type BaseParsedInput,
 	type ExtractResult,
+	type ParserLocale,
+	type DateRange,
+	type ExtractionStep,
 	// Extraction functions
 	extractDate,
+	extractDateRange,
 	extractTime,
+	extractTimezone,
 	extractTags,
 	extractAtReference,
+	extractAtReferences,
+	extractRecurrence,
+	extractRelativeTime,
 	// Combination
 	combineDateAndTime,
 	// Preview formatting
@@ -21,6 +30,9 @@ export {
 	formatDateTimePreview,
 	// Main parser
 	parseBaseInput,
+	// Compose helper
+	createAppParser,
 	// Utilities
 	cleanTitle,
+	fuzzyMatchDateKeyword,
 } from './base-parser';