AI Project Showcase: Personal Assistant

Section 1 — Product Overview

1.1 Product name and tagline

Name: Personal Assistant
Tagline: One Mac-native AI assistant that knows every domain of your life — and routes intelligently to the right expert for every question.
Current status: Live — Production Tauri Desktop App (v3.1 · April 2026); TestFlight distribution active
First commit / project start: February 9, 2026 (first commit in dedicated Personal/personal-assistant git repo)

1.2 What it is

Personal Assistant is a private, Mac-native AI assistant built with Tauri 2.0 (Rust + React + TypeScript) that provides 20 specialized advisors and tools covering every domain of the owner’s life — scuba diving, expat planning, culinary arts, travel, estate and trust management, household operations, marriage, music, career, and more. All data stays local (SQLite) with iCloud CloudKit sync across devices and macOS Keychain for secret management. The app features intelligent auto-routing that scores incoming queries against per-advisor keyword arrays and directs conversations to the right specialist, with dynamic context injection that assembles agent prompts at runtime with budget-controlled knowledgebase loading to prevent context overflow.

1.3 What makes it meaningfully different

• Deep domain specialization across 20 life domains — not a generic chatbot, but 15 auto-routed advisors and 5 dedicated full-screen tools, each backed by curated knowledgebases (scuba: 40+ files including 14,600+ dive sites, 6,900+ dive operators, 17 almanac files, safety engine, and 3 disambiguation dictionaries — synthesized from 3.7GB of training data; expat: 31 files across 4 domain categories; culinary: 5 topic files with 100+ restaurant entries)
• Budget-controlled dynamic prompt assembly — systemPromptBuilder.ts loads only the knowledgebase sections relevant to the current query, with per-advisor character budgets and Set-based deduplication to maximize context quality within token limits
• Full privacy by design — all data local (SQLite + Keychain), zero telemetry, no external analytics, CloudKit sync through Apple’s private container with encryption at rest and in transit
• Native desktop performance — Tauri 2.0 delivers ~3-5MB bundle size and ~80MB memory footprint, far lighter than Electron alternatives
• Deep integrations — Apple Music/MusicKit, Google Gmail/Calendar/Maps Places API, Todoist, Archive.org, Setlist.fm, MusicBrainz, RSS feeds, podcasts, YouTube, weather, and Siri Shortcuts

1.4 Platform and deployment context

Platform: macOS desktop (primary, arm64, macOS 12.0+), iOS (TestFlight)
Deployment: macOS distributed via TestFlight (App Store Connect) and .dmg; built through XcodeGen-managed Xcode wrapper for Apple-managed code signing; iOS builds via Xcode Organizer
Primary interface: Tauri 2.0 WebView (React 18 + TypeScript + Tailwind CSS, Apple HIG design system)
Build pipeline: build.sh orchestrates version syncing → npm build → cargo tauri build --no-bundle → Xcode archive → dSYM regeneration → DMG creation → iOS archive

---

Section 2 — User Needs and Problem Statement

2.1 Target user

Primary user: Single power user (the developer/owner) managing complex life domains across career, family, travel, hobbies, legal obligations, and household
Secondary users: None (private personal application)
User environment: macOS desktop, daily use; iOS for on-the-go access (experimental)

2.2 The problem being solved

Managing information, tasks, and decisions across 20+ distinct life domains (scuba diving, international relocation planning, estate/trust management, household operations, culinary pursuits, career consulting, etc.) creates cognitive overload. Generic AI assistants lack the deep contextual knowledge needed to give expert-level advice in specialized domains, and switching between multiple specialized apps fragments workflows and loses cross-domain context.

2.3 Unmet needs this addresses

Need	How the product addresses it	Source of evidence
Deep domain expertise across diverse life areas	15 specialized advisors with curated knowledgebases (scuba: 40+ files including dive site/operator databases, expat: 31 files, culinary: 5 files, marriage: 5 files)	CLAUDE.md advisor roster, knowledgebase/ directory
Intelligent routing without manual agent selection	Keyword scoring with multi-word phrase boost (2× score) and @mention override	CLAUDE.md routing section, constants.ts
Privacy for sensitive personal data (estate, financial, medical)	All data local (SQLite + Keychain), zero telemetry, CloudKit for sync only	CLAUDE.md security section, README.md
Cross-domain context awareness	Macro Advisor (ID 0) has orchestrator role with full data access across all domains	CLAUDE.md advisor table
Unified access to fragmented tools (email, calendar, music, tasks, feeds)	5 dedicated full-screen tools (Music, News, Feed Reader, Podcasts, YouTube) plus Gmail, Calendar, Todoist integrations	README.md integrations section

2.4 What users were doing before this existed

Switching between ChatGPT/Claude web interfaces (no persistent domain knowledge), multiple standalone apps (Apple Music, Gmail, Google Calendar, Todoist, RSS readers, podcast apps), and maintaining knowledge in scattered documents and notes. No single interface could combine deep domain expertise with task management and media consumption. [CLAUDE NOTE: inferred from feature set]

---

Section 3 — Market Context and Competitive Landscape

3.1 Market category

Primary category: AI-powered personal assistant / life management platform
Market maturity: Emerging — personal AI assistants with deep domain specialization are nascent; most offerings are general-purpose chatbots or narrow single-domain tools ⚡
Key dynamics: Rapid commoditization of general chatbot interfaces; growing demand for personalized, context-rich AI; increasing privacy concerns driving local-first architectures ⚡

3.2 Competitive landscape

Product / Company	Approach	Strengths	Key gap this project addresses	Source
ChatGPT (OpenAI) ⚡	Cloud-based general chatbot with memory	Broad knowledge, GPT-4 capabilities	No deep domain specialization, no local data, no app integrations	Public knowledge
Claude (Anthropic) ⚡	Cloud-based conversational AI	Strong reasoning, long context	No persistent knowledgebase, no native app shell, no integrations	Public knowledge
Apple Intelligence ⚡	OS-level AI features	Deep system integration, privacy	No specialized domain advisors, no custom knowledgebases	Public knowledge
Notion AI ⚡	AI within productivity platform	Good for documents and tasks	No specialized advisors, no media integrations, limited offline	Public knowledge

3.3 Market positioning

This is a private, non-commercial application. Its positioning is not market-facing but rather optimized for a single user’s specific needs: a deeply personalized AI system that combines the conversational intelligence of Claude with curated domain expertise, native desktop performance, full privacy, and unified access to daily tools. [CLAUDE NOTE: inferred — not a commercial product]

3.4 Defensibility assessment

As a personal project, traditional defensibility metrics don’t apply. The primary “moat” is the deeply curated knowledgebase content (synthesized from 3.7GB of scuba training data, 31 expat planning files, 150-term glossary) and the architectural patterns for budget-controlled dynamic prompt assembly — patterns that have been extracted into the ITI Shared Library for reuse across commercial products. [CLAUDE NOTE: inferred]

---

Section 4 — Requirements Framing

4.1 How requirements were approached

Iterative, usage-driven development over multiple major versions. Requirements emerged from daily personal use, with each version adding new domains and integrations based on real needs. Formal requirements documents exist in the requirements/ directory. The ITI Shared Library documents reusable patterns extracted from this project.

4.2 Core requirements

1. Intelligent auto-routing of queries to the correct specialized advisor via keyword scoring
2. Dynamic, budget-controlled knowledgebase injection into agent prompts at runtime
3. All data local (SQLite) with iCloud CloudKit sync — zero external telemetry
4. API key storage in macOS Keychain with iCloud synchronization
5. Streaming Claude AI responses with per-advisor system prompts
6. Deep integrations: Gmail, Google Calendar, Google Maps Places, Apple Music, Todoist, RSS, Podcasts, YouTube
7. Itinerary Kanban with drag-and-drop trip planning and cost roll-up
8. Household management with pet care, plant care, tasks, bills, and weather
9. Module dashboards with per-advisor widgets, feeds, and chat
10. Voice input via Whisper STT + TTS (macOS AVSpeechSynthesizer + iOS)

4.3 Constraints and non-goals

Hard constraints:

• All data must stay local — no external analytics or telemetry
• API keys stored only in macOS Keychain, never in code or config files
• No PII in committed code — personal profile data loaded at runtime from local files
• Security and privacy are top priorities

Explicit non-goals:

• Not a product for distribution — strictly personal use
• No multi-user support beyond single-user CloudKit sync
• Test coverage: pytest 25/25, Rust 117/117, Vitest 96/97

4.4 Key design decisions and their rationale

Decision	Alternatives considered	Rationale	Evidence source
Tauri 2.0 over Electron	Electron, native Swift	~3-5MB bundle / ~80MB memory vs. Electron’s ~150MB+; Rust backend enables native Keychain, CloudKit FFI	CLAUDE.md tech stack, Cargo.toml
SQLite over PostgreSQL / cloud DB	Supabase, Firebase	Local-first privacy; no network dependency; CloudKit handles sync	CLAUDE.md architecture
Budget-controlled KB injection over full KB embedding	Vector-only retrieval, full context stuffing	Prevents context overflow while ensuring relevant content; per-advisor char limits with Set deduplication	CLAUDE.md systemPromptBuilder section
Keyword scoring over LLM-based routing	Embedding-based routing, manual selection	Fast, deterministic, zero-latency routing; multi-word phrases score 2× for precision	CLAUDE.md routing section
Swift FFI bridge for CloudKit	Pure Rust CloudKit (not available), REST API	CloudKit has no public REST API for private databases; Swift bridge via native FFI is the only option	cloudkit.rs, CloudKitBridge.swift
Xcode wrapper for code signing	Direct Tauri bundling, manual codesign	Tauri’s built-in bundler cannot produce Apple-provisioned entitlements for CloudKit; XcodeGen wrapper delegates signing to Xcode’s automatic signing, which correctly provisions CloudKit containers, app sandbox, and Keychain access groups	xcode-wrapper/project.yml, entitlements.plist
App Sandbox with scoped entitlements	Unsandboxed distribution	Required for App Store / TestFlight; scoped to network client/server, audio input, and user-selected file read/write — minimum viable set for all app features	entitlements.plist

---

Section 5 — Knowledge System Architecture

5.1 Knowledge system overview

KB type: Curated structured markdown files with runtime dynamic injection; supplemented by Pinecone vector search
Location in repo: knowledgebase/ (root level, bundled into app via tauri.conf.json resources)
Estimated size: ~500KB+ across 100+ files (scuba: 40+ files including dive site DB, dive operator DB, 17 almanac files, disambiguations, analytics/baselines; expat: 31 files; culinary: 64KB/5 files; marriage: 5 files; travel: multiple subdirectories)

5.2 Knowledge system structure

knowledgebase/
├── culinary/                  # 5 files: BBQ, sourdough, dining, wine/bourbon, entertaining (64KB)
├── scuba/                     # 40+ files: topics, destinations, data, almanac, disambiguations
│   ├── destinations/          # 8 regional destination guides (60+ countries)
│   ├── data/                  # dive-sites.json (14,642), dive-operators.json (6,900+), seasonal-baselines.json, operators.json
│   ├── almanac/               # 17 regional almanac files
│   ├── disambiguations/       # 3 term dictionaries (scuba, coral-reef, fish)
│   ├── analytics/             # Country/region analytics, species-region matrix
│   ├── baselines/             # Seasonal temperature baselines
│   └── templates/             # Data templates for dive sites/operators
├── expat/                     # 31 files across 4 domain categories
│   ├── country-profiles/      # France, Spain, Italy
│   ├── execution-plans/       # 1-5 year plans
│   ├── retirement/            # 6 retirement-specific files
│   └── specialists/           # 6 synthesized specialist summaries
├── marriage/                  # 5 files: frameworks, books, context, science
├── travel/                    # RV reference, destination knowledge, city/trip subfolders
├── career/                    # Career-related knowledge
├── reference-data/            # Reference data files
├── index/                     # Knowledge indices
├── summaries/                 # Summary files
└── *.md                       # Core profile, dive summary, active projects, etc.

5.3 Knowledge categories

Category	Files / format	Purpose	Update frequency
Scuba	40+ files including dive site DB (14,642 sites), dive operator DB (6,900+ operators), 17 almanac files, 3 disambiguation dictionaries, 6 analytics/baselines files — synthesized from 3.7GB training data and ScubaGPT parity pipeline	Destinations (60+ countries), dive operators (6,900+), safety analysis (medical/gas detection, cert limits, DAN referral), marine conditions, terminology disambiguation, marine life (50+ species), equipment, wrecks, seasonal planner	Actively maintained — full ScubaGPT parity as of April 2026
Expat Planning	31 markdown files across country-profiles/, execution-plans/, retirement/, specialists/	France/Spain/Italy relocation: visa, tax, property, retirement, specialist summaries	Active research phase — updated regularly
Culinary	5 markdown files (64KB)	BBQ/smoking, sourdough, Atlanta dining (100+ restaurants), wine/bourbon (75+ award-winning), entertaining	Periodically
Marriage	5 markdown files	Gottman frameworks, EFT, trauma recovery, breadwinner dynamics, relationship context	As needed
Travel	Multiple files across subdirectories	RV reference, destination knowledge, pet travel	As trips are planned
Core Profile	Root-level markdown files	Personal profile, dive summary, active projects, estate context	As life changes

5.4 How the knowledge system was built

1. Scuba knowledgebase — Synthesized from 3.7GB of training data originally assembled for the ScubaGPT commercial product; now at full parity with ScubaGPT including 14,642 dive sites, 6,900+ dive operators (World Dive Centres API), 17 regional almanac files, 3 disambiguation dictionaries, safety analysis engine, and 6 analytics/baselines files
2. Expat knowledgebase — Built through iterative research across the companion expat-advisor project; 31 files covering country profiles, execution plans, retirement planning, and synthesized specialist summaries
3. Culinary knowledgebase — Curated from personal dining experiences (100+ Atlanta restaurants), BBQ/smoking expertise, sourdough baking knowledge, and wine/bourbon research
4. Marriage knowledgebase — Compiled from Gottman Institute frameworks, EFT research, and relationship science
5. All files — Structured as token-efficient markdown; no binary files committed; maintained through Cursor/Claude Code sessions

5.5 System prompt and agent configuration

System prompt approach: Base system prompt (prompts/system-prompt.txt) provides identity and biographical context; per-agent prompts (agents/*.md, 23+ files) define domain expertise; systemPromptBuilder.ts assembles the final prompt at runtime by combining base + agent prompt + dynamically loaded KB sections
Key behavioural guardrails: Per-agent guardrails in guardrails/context-guardrails.md; disambiguation rules in disambiguations/context-terms.md; 150-term glossary (documentation/glossary.md) with {curly bracket} convention for canonical definitions
Persona / tone configuration: Per-advisor personality defined in agent prompt files; tone varies by domain (e.g., Scuba Advisor is enthusiastic and safety-conscious; Estate Advisor is formal and precise) [CLAUDE NOTE: inferred from agent file structure]
Tool use / function calling: Tavily web search with per-agent trusted domain lists; Pinecone vector search for semantic retrieval; Google Places API, Gmail, Calendar, Todoist, Apple Music/MusicKit APIs called via Rust backend commands

---

Section 6 — Build Methodology

6.1 Development approach

AI-assisted iterative development using Cursor IDE and Claude Code. The project evolved through three major versions, each expanding domain coverage, integrations, and architectural sophistication. Patterns proven in this personal project are extracted into the ITI Shared Library for reuse across commercial products.

6.2 Build phases

Phase	Approximate timeframe	What was built	Key commits or milestones
v1.0 / pre-v2.8	Pre-February 2026 [CLAUDE NOTE: predates dedicated git repo]	Initial Tauri app with basic chat and a few advisors	First dedicated repo commit 2026-02-09 already contained a substantial app
v2.8.0	2026-03-11	Feed Reader Phase 2, music advisor improvements, initial CloudKit sync scaffolding	DMG Personal_Assistant_v2.8.0_20260311.dmg on disk
v2.9.0	March 2026	Marital advisor, expanded scuba KB, full CloudKit sync coverage, help system overhaul	DMG Personal Assistant_2.9.0_aarch64.dmg
v3.0.0	March 2026 (CHANGELOG [3.0.0] – 2026-03; DMG Personal_Assistant_3.0.0_20260405.dmg)	Best-of-breed scuba KB (17 files / ~196KB), expat KB (31 files), culinary KB (5 files), dynamic budget-controlled prompt injection, Patriot Agent, YouTube Library tool, Google OAuth auto-refresh, Todoist + CloudKit retry logic, explicit API timeouts	Feature-complete production release
v3.0.0 infrastructure	April 15-16, 2026	CloudKit sync stabilization (migrated to new container iCloud.com.peterwesterman.pa-test), Xcode wrapper build pipeline (XcodeGen + automatic signing), App Sandbox with scoped entitlements, TestFlight distribution (macOS), dSYM regeneration from Rust binary, build.sh orchestration script, iOS archive in Xcode Organizer	Distribution-ready — TestFlight active
	v3.1	April 2026	9-phase scuba/travel parity with ScubaGPT and My TravelPlanner: 14,642 dive sites, 6,900+ dive operators (World Dive Centres API), 5 new Rust modules (dive_operators.rs, scuba_safety.rs, currency_exchange.rs, carbon_calculator.rs, esim_advisor.rs), 14 new Tauri commands, 3 product-level Skills (dive-operator-search, scuba-safety-analysis, travel-data-services), 1 product-level Agent (scuba-data-steward), scuba disambiguation system (3 dictionaries), 17 regional almanac files, 6 analytics/baselines files, Pinecone RAG with compound scuba/operator filters. Travel Advisor: currency exchange (Frankfurter/ECB), carbon footprint (ICAO/DEFRA), eSIM (Airalo/Holafly/Nomad). Expat Advisor: currency exchange and eSIM services. Tests: pytest 25/25, Rust 117/117 (up from ~77), Vitest 96/97	Scuba/travel parity release

6.3 Claude Code / AI-assisted development patterns

• Cursor IDE as primary development environment with CLAUDE.md providing full project context
• Claude Code for complex refactoring, cross-file changes, and CLAUDE.md stewardship
• Agent prompt files authored collaboratively with Claude — domain expertise from human, structural optimization from AI
• Knowledgebase files synthesized from training data using Claude for distillation and structuring
• ITI Shared Library patterns extracted from proven implementations in this project

6.4 Key technical challenges and how they were resolved

Challenge	How resolved	Evidence
CloudKit has no public REST API for private databases	Built Swift FFI bridge (CloudKitBridge.swift) called from Rust via native bindings	cloudkit.rs, cloudkit_sync.rs, swift/CloudKitBridge.swift
Context overflow when loading large knowledgebases	Budget-controlled dynamic injection with per-advisor char limits (scuba: 60K, marital: 30K) and Set-based deduplication	CLAUDE.md systemPromptBuilder section
Bidirectional sync with conflict resolution	Dirty detection (ck_record_id IS NULL OR updated_at > ck_modified_at), 2-second debounce, exponential backoff retry, last-writer-wins (single-user)	CLAUDE.md CloudKit sync section
Google OAuth token management across multiple services	Centralized with_google_auth helper in lib.rs with automatic token refresh and retry	CLAUDE.md API reliability section
Todoist API rate limiting	todoist_request respects 429 status + Retry-After header with transient retry logic	todoist.rs
CloudKit container corruption	Original iCloud.com.peterwesterman.personal-assistant container became permanently invalid on Apple’s servers; migrated to new iCloud.com.peterwesterman.pa-test container; required coordinated updates across entitlements, Swift bridge, and provisioning profiles	CloudKitBridge.swift, entitlements.plist
Tauri binary code signing for CloudKit	Tauri’s built-in bundler cannot provision CloudKit entitlements; codesign --force --deep corrupts nested signatures. Built XcodeGen wrapper project that delegates to Xcode’s automatic signing, with post-build script that runs cargo tauri build --no-bundle and assembles the app bundle manually	xcode-wrapper/project.yml
dSYM UUID mismatch in Xcode archives	Xcode generated dSYM for the dummy Swift stub, not the Rust binary; TestFlight rejected the upload. Post-archive step regenerates dSYM from the actual Rust binary via dsymutil	build.sh
TestFlight distribution compliance	Four successive upload rejections: deployment target (macOS 12.0+), app sandbox, LSApplicationCategoryType, and dSYM UUID. Each resolved through iterative entitlements and build configuration fixes	entitlements.plist, project.yml, build.sh

---

Section 7 — AI Tools and Techniques

7.1 AI models and APIs used

Model / API	Provider	Role in product	Integration method
Claude (claude-3-7-sonnet)	Anthropic	Primary AI for all 15 advisors — streaming responses with dynamic context injection	Direct API via Rust reqwest HTTP client, streaming SSE
Tavily Search	Tavily	Real-time web search enrichment with per-agent trusted domain lists	REST API via Rust backend
Pinecone	Pinecone	Vector search for semantic retrieval across knowledgebase	REST API via pinecone.rs
OpenAI Embeddings	OpenAI	Embedding generation for Pinecone vector store	REST API via embeddings.rs (CSP allows api.openai.com)
Gemini	Google	Enrichment capabilities	REST API via gemini.rs
Whisper (whisper-1)	OpenAI	Speech-to-text voice input	REST API (api.openai.com/v1/audio/transcriptions) via Rust whisper_transcribe command in lib.rs
OpenAI TTS	OpenAI	Text-to-speech voice output	REST API (api.openai.com/v1/audio/speech) via Rust backend

7.2 AI orchestration and tooling

Tool	Category	Purpose
systemPromptBuilder.ts	Prompt assembly	Dynamic, budget-controlled KB injection per advisor at runtime
agentRouter.ts	Routing	Keyword-scored auto-routing to correct advisor
agentConfigLoader.ts	Configuration	Agent prompt file loading and configuration
parallelAgents.ts	Orchestration	Multi-agent workflow coordination
intentDetection.ts	NLU	Intent classification for routing decisions
proactiveEngine.ts	Proactive AI	Memory-based proactive suggestions
conversationSummarizer.ts	Context management	Conversation compression for long sessions
modelTiering.ts	Model selection	Model selection logic
n8nClient.ts / n8nOrchestrator.ts	Workflow	n8n webhook integration for workflow orchestration

7.3 Prompting techniques used

• [x] Dynamic context injection with budget-controlled KB loading
• [x] Per-advisor specialized system prompts (23+ agent prompt files)
• [x] Keyword-triggered knowledgebase section loading (e.g., scuba: 10 keyword groups for destinations, 9 for topics)
• [x] Character budget management with Set-based deduplication
• [x] Disambiguation rules for ambiguous cross-domain terms
• [x] Guardrails for per-agent behavioral boundaries
• [x] 150-term canonical glossary with {curly bracket} assertion convention
• [x] Persona-specific tone and expertise definitions per agent
• [x] Streaming response delivery

7.4 AI development tools used to build this

Tool	How used in build
Cursor IDE	Primary development environment; CLAUDE.md context for all coding sessions
Claude Code	Complex refactoring, cross-file changes, CLAUDE.md stewardship
Claude (conversational)	Knowledgebase synthesis, agent prompt authoring, architecture design
Antigravity	Used per global CLAUDE.md tool lane (autonomous test execution, browser QA) [CLAUDE NOTE: inferred from ~/CLAUDE.md — not explicitly referenced in this project’s own CLAUDE.md]

---

Section 8 — Version History and Evolution

8.1 Version timeline

Version / Phase	Date	Summary of changes	Significance
Pre-repo era	Before 2026-02-09 [CLAUDE NOTE: predates dedicated git repo]	Initial Tauri desktop app with basic advisor chat	Foundation
v2.8.0	2026-03-11	Feed Reader Phase 2, music advisor, CloudKit scaffolding	DMG on disk
v2.9.0	Mid-March 2026	Marital advisor, CloudKit sync, help system	DMG on disk
v3.0.0	April 5, 2026 (DMG) / CHANGELOG [3.0.0] – 2026-03	20 advisors/tools, dynamic budget-controlled KB injection, Pinecone vector search, module dashboards, voice (OpenAI Whisper STT + TTS), Siri Shortcuts, itinerary Kanban, household suite, Patriot Agent, YouTube Library, API reliability hardening	Feature-complete production release
v3.0.0 infra	April 15-16, 2026	CloudKit container migration (pa-test), Xcode wrapper build pipeline, App Sandbox, TestFlight macOS distribution, build.sh orchestration, dSYM fix, iOS archive	Distribution-ready — TestFlight active, cloudkit-tauri-debugging skill extracted
	v3.1	April 2026	9-phase scuba/travel parity: 14,642 dive sites, 6,900+ dive operators, 5 new Rust modules, 14 Tauri commands, 3 Skills, 1 Agent, scuba disambiguation, 17 almanac files, Pinecone compound filters. Travel: currency exchange, carbon footprint, eSIM. Tests: pytest 25/25, Rust 117/117, Vitest 96/97	Scuba/travel parity — full ScubaGPT + My TravelPlanner feature match

8.2 Notable pivots or scope changes

• Scuba knowledgebase was synthesized from the commercial ScubaGPT product’s 3.7GB training data, representing a knowledge transfer from commercial to personal project
• Expat knowledgebase was merged from the companion expat-advisor project (31 files)
• Travel knowledge was merged from the commercial My TravelPlanner product
• Evolution from simple chatbot to multi-agent system with dedicated full-screen tools for media (Music, News, Feeds, Podcasts, YouTube)

8.3 What has been cut or deferred

• Full test suite now active: pytest 25/25, Rust 117/117 (up from ~77), Vitest 96/97
• iOS build is in Xcode Organizer but not yet uploading to TestFlight — macOS TestFlight distribution is active
• Evernote integration (evernote.rs exists but status unclear) [CLAUDE NOTE: inferred from file presence]
• Sonos integration (sonos.rs exists, CSP allows api.sonos.com) [CLAUDE NOTE: inferred from file presence]
• WordPress sync (wordpress_sync.rs exists) [CLAUDE NOTE: inferred from file presence]

---

Section 9 — Product Artifacts

9.1 Design and UX artifacts

Artifact	Path	Type	What it shows
Apple HIG Implementation Guide	documentation/APPLE-HIG-IMPLEMENTATION-GUIDE.md	Design reference	UI design standards and Apple HIG compliance
Design tokens	src/styles/design-tokens.css	CSS tokens	Color, spacing, typography design system
Modern layout styles	src/styles/modern-layout.css	CSS	Layout system for module dashboards

9.1b Build and deployment artifacts

Artifact	Path	Type	What it shows
Build orchestration script	personal-assistant-app/build.sh	Shell	Version syncing, Xcode archive, dSYM regeneration, DMG creation, iOS archive — single-command build
Xcode wrapper project	personal-assistant-app/xcode-wrapper/project.yml	XcodeGen spec	Xcode project for Apple-managed automatic signing; post-build script assembles Tauri binary + resources into app bundle
Entitlements	personal-assistant-app/src-tauri/entitlements.plist	Plist	App Sandbox, CloudKit container (iCloud.com.peterwesterman.pa-test), Keychain access groups, network + audio + file entitlements
CloudKit Swift bridge	personal-assistant-app/src-tauri/swift/CloudKitBridge.swift	Swift	FFI bridge exposing CloudKit operations (save, fetch, delete, zone creation) to Rust backend

9.2 Documentation artifacts

Document	Path	Type	Status
CLAUDE.md	CLAUDE.md	AI context	Current (March 2026)
README.md	README.md	Overview	Current (March 2026)
Help system	documentation/help-system.md	User help	Complete (22 sections)
Glossary	documentation/glossary.md	Vocabulary	150+ terms defined
Setup guide	documentation/SETUP-GUIDE.md	Dev setup	Current
Quick start	documentation/QUICK-START.md	Getting started	Current
Tavily-Pinecone architecture	documentation/TAVILY-PINECONE-ARCHITECTURE.md	Architecture	Current
CHANGELOG	CHANGELOG.md	Version history	Current

9.3 Data and output artifacts

Artifact	Path	Description
Agent prompts	agents/ (23+ files)	Specialized advisor prompt definitions
Knowledgebase	knowledgebase/ (60+ files)	Curated domain knowledge across scuba, expat, culinary, marriage, travel, career
Guardrails	guardrails/	Per-agent behavioral safety boundaries
Disambiguations	disambiguations/	Cross-domain term disambiguation rules
Music taste profile	music recommender/personal_music_taste_profile.md + .json	Music preference data for Music Advisor
Music inventory	music recommender/_music_inventory.csv	Music library data
Feed subscriptions	requirements/feedly.opml	RSS feed subscription export
Podcast subscriptions	requirements/Overcast Podcast Subscriptions.opml	Podcast subscription export

---

Section 10 — Product Ideation Story

10.1 Origin of the idea

The project originated from the need to manage an increasingly complex personal life spanning multiple domains — from advanced scuba diving (155+ dives, PADI Advanced OW) and international relocation planning to estate/trust management, household operations, and career consulting. No existing AI assistant provided the deep, persistent domain knowledge needed to give expert-level advice across all these areas simultaneously. [CLAUDE NOTE: inferred from CLAUDE.md and README.md context]

10.2 How the market was assessed

As a personal project, formal market assessment was not conducted. The “market” is a single user with specific, well-understood needs. The decision to build was driven by daily friction with existing tools rather than market opportunity analysis. [CLAUDE NOTE: inferred]

10.3 The core product bet

That a single, privacy-first desktop application with deeply curated domain knowledge and intelligent routing could replace a fragmented ecosystem of generic AI chatbots, standalone apps, and scattered documents — delivering expert-level advice across 20+ life domains while keeping all data local and under the user’s control. [CLAUDE NOTE: inferred]

10.4 How the idea evolved

The project evolved from a simple chatbot into a comprehensive life management platform through three major versions. Key evolution milestones include: the addition of CloudKit sync for cross-device access, the development of budget-controlled dynamic prompt assembly to handle growing knowledgebases, the integration of external services (Google, Apple Music, Todoist), the creation of dedicated full-screen tools for media consumption, and the extraction of proven patterns into the ITI Shared Library for commercial reuse. The scuba knowledgebase was enriched through cross-pollination with the commercial ScubaGPT product, and the expat knowledgebase was consolidated from the companion expat-advisor project. [CLAUDE NOTE: inferred from version history and related project references]

---

Section 11 — Lessons and Next Steps

11.1 Current state assessment

What works well:

• Intelligent auto-routing consistently directs queries to the correct advisor
• Dynamic KB injection with budget controls prevents context overflow while maintaining relevance
• CloudKit sync provides seamless cross-device experience
• 20 advisors/tools cover all major life domains
• Deep integrations (Gmail, Calendar, Maps, Music, Todoist) reduce app switching
• Privacy architecture ensures all sensitive data stays local

Current limitations:

• iOS build exists in Xcode Organizer but not yet on TestFlight (macOS TestFlight is active)
• Test suite: pytest 25/25, Rust 117/117, Vitest 96/97 — comprehensive coverage achieved in v3.1
• Single-user architecture by design
• Memory system specified but unimplemented — advisors don’t persist context across sessions
• Some integrations may be partially implemented (Evernote, Sonos, WordPress sync) [CLAUDE NOTE: inferred from file presence]

Estimated completeness: 90% — fully functional production app for daily use; iOS and some integrations remain experimental

11.2 Visible next steps

1. Complete iOS TestFlight distribution (macOS is active; iOS archive exists in Xcode Organizer)
2. Implement memory system (full spec exists at memory-system-requirements.md)
3. Upgrade to Claude 4 Sonnet (currently on claude-3-7-sonnet)
4. Implement Retiree Mode Phases 1-2 (imminent real-life need; skills ready)
5. Implement advisor action framework (skills agentic-task-execution and advisor-action-framework are ready)
6. Continue expanding knowledgebases as new domains emerge

11.3 Lessons learned

_Manual input required — this section cannot be populated automatically._

---

Section 12 — Claude Code Validation Checklist

• [x] Every placeholder has been replaced or marked NOT FOUND
• [x] All externally-sourced competitive data is marked with ⚡
• [x] All inferences are marked with [CLAUDE NOTE]
• [x] Version history is derived from git log (first commit 2026-02-09), CHANGELOG.md, and on-disk DMG filenames
• [x] Knowledge system paths reflect real directory structure
• [x] AI tools are confirmed from code/config, not guessed
• [x] Section 11.3 is left blank for manual input
• [x] Document header shows April 16, 2026 date and expanded sources list

---

Sources Examined

File / Path	What it contributed
CLAUDE.md	Tech stack, directory structure, advisors/tools roster, architecture patterns, development commands, coding conventions, security, related projects
README.md	Product description, features, integrations, architecture overview, documentation index
personal-assistant-app/package.json	Version (3.0.0), dependencies (React 18, Tauri, dnd-kit, zustand, react-markdown), dev dependencies (Vite, Tailwind, Vitest, TypeScript)
personal-assistant-app/src-tauri/Cargo.toml	Rust dependencies (reqwest, rusqlite, tokio, chrono, aes-gcm, jsonwebtoken, serde_yaml, cpal), platform-specific deps (Keychain, iOS), version confirmation
personal-assistant-app/src-tauri/tauri.conf.json	App configuration, CSP (reveals all API endpoints/services), bundle resources, signing identity, deep-link schemes, window configuration
personal-assistant-app/src/ directory structure	Frontend architecture: components, hooks, utils, modules, services, styles, types, tests
personal-assistant-app/src-tauri/src/ directory structure	Backend modules: database, cloudkit, keychain, Google services, media APIs, Atlanta APIs, scuba/marine (incl. dive_operators.rs, scuba_safety.rs), weather, todoist, anylist, household, AI/search services, travel utilities (currency_exchange.rs, carbon_calculator.rs, esim_advisor.rs)
knowledgebase/ directory structure	Domain coverage: scuba, expat, culinary, marriage, travel, career, plus root-level profile/context files
agents/ directory	23+ agent prompt files for all advisors
documentation/ directory	Help system, glossary, setup guides, architecture docs
personal-assistant-app/xcode-wrapper/project.yml	XcodeGen spec: deployment target, signing, entitlements path, post-build script, app category
personal-assistant-app/build.sh	Build orchestration: version syncing, Xcode archive, dSYM regeneration, DMG creation
personal-assistant-app/src-tauri/entitlements.plist	App Sandbox, CloudKit container (iCloud.com.peterwesterman.pa-test), Keychain access groups, scoped entitlements
personal-assistant-app/src-tauri/swift/CloudKitBridge.swift	CloudKit container identifier, FFI bridge architecture

---

Addendum — April 2026 Competitive Landscape and Roadmap Update

1. Industry Context

The personal AI assistant landscape has undergone the most dramatic competitive shift of any domain in the ITI portfolio. In the six months since Personal Assistant v3.0 shipped, every major platform has launched agentic capabilities: ChatGPT Agent executes autonomous multi-step web tasks, Claude Cowork controls the Mac desktop, Gemini Agent handles multi-step actions, and Amazon Alexa+ ships Claude-powered natural language routines. Agentic AI — assistants that don’t just advise but act — is now table stakes. Personal Assistant’s advisors still operate in a request-response loop.

The vibe coding ecosystem ($9.4 billion funded, 41% of code AI-generated) has spawned open-source alternatives like OpenYak (Tauri + local-first, 100+ models) that directly overlap with Personal Assistant’s architecture choices. But the more consequential threat is Apple: iOS 27’s rebuilt Siri (powered by Google’s 1.2T Gemini model, announced for WWDC June 2026) will ship with a chat app, conversation history, cross-app workflows, and third-party AI extensions — directly overlapping with Personal Assistant’s core value proposition on macOS and iOS. This isn’t a startup competitor; it’s the OS vendor building it into the platform.

LLM convergence cuts both ways for Personal Assistant. On one hand, Claude 4, GPT-5, and Gemini 2.5 all offer strong reasoning, long context (up to 2M tokens), and tool calling — meaning the AI capabilities backing Personal Assistant’s advisors can be matched by any competitor. On the other hand, the convergence validates Personal Assistant’s architectural bet: the value isn’t in the model, it’s in the 100+ file curated knowledgebases, the budget-controlled dynamic prompt assembly, the 15-advisor auto-routing, and the deep integrations. No competitor has 20 life domains covered with curated, persistent domain knowledge.

2. Competitive Landscape Changes

Major Competitors (April 2026)

Competitor	Type	Key Threat	Threat Level
ChatGPT (Agent + Operator)	Cloud chatbot + agent	10K+ memory facts, Agent mode, Operator (computer use), desktop app	High
Claude Desktop + Cowork	Cloud chatbot + desktop agent	Computer use (Mac control), MCP extensions, Dispatch (mobile→desktop)	High
Google Gemini Agent	Cloud assistant + agent	Autonomous multi-step tasks, Google Workspace integration	Medium
Apple Siri (iOS 27)	OS-level assistant	Gemini 1.2T backend, chat app, cross-app workflows, third-party extensions	High
Raycast AI	Mac launcher + AI	32+ models, 1,300+ extensions, SOC 2, command bar interface	Medium
Amazon Alexa+	Voice + smart home	Claude-powered NLU, natural routines, context memory	Low
OpenYak	Open-source Tauri desktop agent	Local-first, 100+ models, Ollama support	Low

Features Competitors Have Added (Jan-Apr 2026)

Feature	Who Shipped It	Relevance to PA
Autonomous agent mode (browse, act, execute)	ChatGPT, Gemini, Claude Cowork	Critical gap — PA advisors only talk, not act
Computer use / screen control	Claude Desktop, ChatGPT Operator	Medium — useful but privacy-sensitive
MCP tool protocol (universal)	Claude, GPT, Gemini, Cursor, Copilot	High — PA should adopt for extensibility
Persistent memory (10K+ facts)	ChatGPT, Claude, Gemini	Critical gap — PA memory spec exists but unimplemented
Mobile dispatch → desktop execution	Claude Dispatch	Medium — PA has Siri Shortcuts but no async dispatch
Third-party AI extensions for Siri	Apple (WWDC June 2026)	High — could make PA’s iOS story easier or obsolete

Eroded vs. Sustained Differentiators

Feature	Status
Persistent domain knowledge	Partially eroded — ChatGPT (10K facts), Claude Projects (200K tokens). PA’s 100+ file curated KB still far deeper in specific domains
Privacy/local-first architecture	Partially eroded — OpenYak, Ollama ecosystem. PA remains more complete
Intelligent auto-routing to 15+ domain experts	Still unique — no competitor routes to domain specialists
Budget-controlled dynamic prompt injection	Still unique — architectural advantage
Deep Apple Music integration	Still unique
Cross-border expat/retirement planning KB	Still unique
Itinerary Kanban with cost roll-up	Still unique for an AI assistant
20 life domains covered with curated knowledge	Still unique

3. Our Competitive Response: Product Roadmap

The roadmap optimizes for daily workflow reduction for a single power user. Market positioning is irrelevant — this is a personal tool.

Tier 1 — Critical: (1) Implement the memory system — full spec exists at memory-system-requirements.md; the #1 user pain point industry-wide (34% of AI complaints per Indie Hackers analysis) and the single most impactful feature for daily utility. (2) Upgrade to Claude 4 Sonnet — PA is on claude-3-7-sonnet; Claude 4 offers better reasoning, tool use, and context handling. (3-4) Retiree Mode Phases 1-2 — toggle, profile, 4 DB tables, SS Optimizer, RMD Calculator, Roth Conversion Optimizer, Medicare IRMAA Calculator. Imminent real-life need. (5) Advisor action framework — structured tool calls so advisors can create calendar events, add Todoist tasks, send email drafts, and save notes rather than just suggesting them.

Tier 2 — High Value: Retiree Mode Phase 3 (cross-border calculators: US/Spain/France tax, Totalization, healthcare cost comparator). Daily Planner / command center (unified Google Calendar + Todoist + Gmail view). Proactive morning briefing. Conversation summarization. Music listening context awareness. Wire proactive engine.

Tier 3 — Strategic: MCP server support for tool extensibility. Multi-agent workflows (Macro Advisor orchestrating cross-domain: Scuba→Travel→Calendar→Budget). Retiree Mode Phases 4-5 (dashboard, withdrawal planning, Monte Carlo). Investment Advisor. Sonos multi-room. Shazam/ShazamKit. Formal test suite. IMDB integration.

Tier 4 — Exploratory: Local model fallback via Ollama, iOS production build, computer use/screen control, Evernote integration, collaborative features, plugin system, PDF generation for financial plans.

Deprioritized: Rabbit R1 / Humane AI Pin competitive response (struggling products, not a real threat), multi-AI model support (Claude remains best-in-class; Ollama covers offline), WordPress sync (no daily utility), email filtering agent (Gmail’s native filtering suffices).

4. New Capabilities Added Since Last Build

The following Skills have been added to the ITI skill library since the showcase was written, directly supporting roadmap execution:

Skill	Relevance to Personal Assistant
agentic-task-execution	Patterns for Claude tool use to execute real-world tasks (sending emails, booking, purchasing) with safety guardrails, confirmation flows, and rollback — core to Tier 1 advisor action framework
advisor-action-framework	Pattern for AI advisors proposing confirmable real-world actions via structured tool calls — directly implements the Tier 1 agentic capability
retirement-calculator-engine	Rust-based financial calculation patterns (SS optimizer, RMD, Roth conversion, IRMAA) for on-device execution — core to Retiree Mode Phases 1-4
mcp-client-tauri	MCP client implementation for Tauri/Rust desktop applications — supports Tier 3 MCP adoption
proactive-briefing-engine	Pattern for aggregating multi-source data into personalized daily briefings — supports Tier 2 morning briefing
expat-tax-compliance	Cross-border tax compliance guidance (FBAR, FATCA, FEIE, treaty interpretation) — supports Retiree Mode Phase 3 cross-border calculators
eventkit-calendar-sync	Apple EventKit and CalDAV integration — supports Daily Planner calendar unification
cloudkit-tauri-debugging	Six-layer diagnostic for CloudKit + Tauri failures (container validation, code signing, asset embedding, build pipeline, TestFlight distribution, App Store Connect configuration) — extracted directly from the April 2026 debugging sessions that stabilized Personal Assistant’s CloudKit sync and TestFlight distribution

5. Honest Assessment

Strengths: Personal Assistant at v3.1 is a genuinely functional, daily-use production application with 20 advisors/tools covering every major life domain. The intelligent auto-routing consistently directs queries to the correct specialist. The dynamic KB injection with budget controls prevents context overflow while maintaining relevance. CloudKit sync — after extensive debugging of container corruption, code signing, and entitlement issues in April 2026 — is now stable and working across devices. The privacy architecture (SQLite + Keychain, zero telemetry) is a real advantage as the industry moves toward cloud-dependent assistants. macOS builds are now distributing via TestFlight, with an Xcode wrapper build pipeline that properly handles Apple’s code signing requirements for CloudKit. At 90% estimated completeness for core functionality, this is the most mature product in the personal portfolio.

Gaps: The two critical gaps are memory (advisors don’t learn across sessions — the #1 complaint about AI tools industry-wide) and agentic capabilities (advisors advise but don’t act — every major competitor now ships autonomous execution). The memory system has a complete spec but is unimplemented. Retiree Mode has a detailed 576-line spec but is unimplemented, and it serves an imminent real-life need. The model is one generation behind (claude-3-7-sonnet vs. Claude 4). iOS builds are in Xcode Organizer but not yet uploading to TestFlight (macOS distribution is active). Test suite expanded to pytest 25/25, Rust 117/117, Vitest 96/97 — addressing the earlier gap.

What we’re watching: Apple’s Siri overhaul (iOS 27, WWDC June 2026) is the single biggest external variable. If the rebuilt Siri — with chat history, cross-app workflows, and third-party AI extensions — is good enough for casual queries, Personal Assistant’s value concentrates further into deep domain expertise, which is exactly where generic assistants cannot compete. The MCP ecosystem evolution matters too: if MCP becomes the universal tool protocol (it’s already adopted by Claude, ChatGPT, Gemini, Cursor, and Copilot), Personal Assistant should consume MCP servers rather than building bespoke Rust integrations for every new service.

Portfolio context: Personal Assistant is the foundational product in the ITI portfolio — the proving ground where architectural patterns are validated before extraction to the ITI Shared Library. Budget-controlled dynamic prompt assembly, keyword-scored auto-routing, CloudKit sync via Swift FFI bridge, multi-advisor orchestration, and the Xcode wrapper build pipeline for Tauri + CloudKit all originated here and are now reusable patterns. The April 2026 CloudKit debugging sessions produced the cloudkit-tauri-debugging skill — a six-layer diagnostic checklist now available to all ITI agents — demonstrating how operational debugging gets codified into the skills library. The product demonstrates ITI’s ability to build deeply personalized AI systems with privacy-first architecture, broad third-party integrations, and domain expertise that no general-purpose AI assistant can match. It is portfolio evidence of full-stack AI product development — not a consumer product competing for downloads.