feat(meeting+social): Meeting Intelligence Stack + LinkedIn/X automation

Phase 1: Post-meeting debrief → structured output + Gmail draft + TASKS.md
Phase 2: Pre-meeting brief → calendar + Gmail/Drive/web → 1-page cheat sheet
Phase 3: Real-time sidebar → 30s refresh, Screenpipe + Whisper, internal-only
consent_guard.py: enforces two-party consent laws in code, blocks external meetings

Social automation: LinkedIn (Playwright) + X/Twitter (tweepy v4) + post scheduler
7 new MCP tools (21 total), 45 new tests, ~$2.35/month total cost

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: wjlgatech

.github/ISSUE_TEMPLATE/bug_report.md

@@ -0,0 +1,22 @@
+---
+name: Bug Report
+about: Report a bug
+labels: bug
+---
+
+## What happened?
+<!-- Clear description of the bug -->
+
+## Expected behavior
+<!-- What should have happened instead -->
+
+## Steps to reproduce
+1.
+2.
+3.
+
+## Environment
+- OS:
+- Python version:
+- WorkflowX version:
+- Screenpipe version (if relevant):

.github/ISSUE_TEMPLATE/feature_request.md

@@ -0,0 +1,17 @@
+---
+name: Feature Request
+about: Propose a new feature or improvement
+labels: enhancement
+---
+
+## What problem does this solve?
+<!-- Describe the friction or gap this addresses -->
+
+## Proposed solution
+<!-- How should it work? Be specific about the mechanism. -->
+
+## Alternatives considered
+<!-- What else did you consider? Why is this better? -->
+
+## Implementation notes
+<!-- Any technical details, affected files, or dependencies -->

.github/workflows/ci.yml

@@ -0,0 +1,53 @@
+name: CI
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version: ["3.10", "3.11", "3.12"]
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up Python ${{ matrix.python-version }}
+        uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+
+      - name: Install dependencies
+        run: |
+          python -m pip install --upgrade pip
+          pip install -e ".[all,dev]"
+
+      - name: Lint
+        run: ruff check src/ tests/
+
+      - name: Type check
+        run: mypy src/workflowx/ --ignore-missing-imports
+
+      - name: Test
+        run: pytest tests/unit/ -v --cov=workflowx --cov-report=xml
+
+      - name: Upload coverage
+        if: matrix.python-version == '3.12'
+        uses: codecov/codecov-action@v4
+        with:
+          file: coverage.xml
+          fail_ci_if_error: false
+
+  format-check:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+      - run: pip install ruff
+      - run: ruff format --check src/ tests/

.gitignore

@@ -0,0 +1,40 @@
+# Python
+__pycache__/
+*.py[cod]
+*.egg-info/
+dist/
+build/
+*.egg
+.eggs/
+
+# Virtual environments
+.venv/
+venv/
+env/
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+
+# Testing
+.pytest_cache/
+.mypy_cache/
+.ruff_cache/
+htmlcov/
+.coverage
+coverage.xml
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Environment
+.env
+.env.local
+
+# Data (user's Screenpipe data should never be committed)
+*.sqlite
+*.db
+data/

CLAUDE.md

@@ -0,0 +1,124 @@
+# WorkflowX — AI Developer Context
+
+## What This Is
+WorkflowX is a workflow intelligence system. It reads events from screen capture tools
+(Screenpipe, ActivityWatch), clusters them into workflow sessions, uses LLMs to infer
+what the user was trying to do, diagnoses friction, generates replacement workflows
+(connected to Agenticom for execution), and measures whether replacements actually work.
+A background daemon runs the full pipeline automatically on a smart schedule.
+
+## Repository Structure
+```
+src/workflowx/
+├── models.py           # Core Pydantic domain models (the contract)
+├── config.py           # Config from env vars / .env
+├── storage.py          # Local JSON storage (file-per-day, patterns, outcomes)
+├── export.py           # JSON/CSV export for external analysis
+├── measurement.py      # Before/after ROI tracking
+├── dashboard.py        # HTML ROI dashboard (static snapshot + live server mode)
+├── server.py           # Live dashboard HTTP server (GET / and GET /api/data)
+├── daemon.py           # Background scheduler — all pipeline stages, smart cadences
+├── notifications.py    # macOS native notifications via osascript
+├── mcp_server.py       # MCP server for Claude/Cursor integration
+├── capture/            # Adapters for data sources
+│   ├── screenpipe.py   # Reads Screenpipe's SQLite DB
+│   └── activitywatch.py # Reads ActivityWatch REST API
+├── inference/          # The intelligence layer
+│   ├── clusterer.py    # Groups raw events into workflow sessions
+│   ├── intent.py       # LLM-based intent inference + classification questions
+│   ├── reporter.py     # Daily/weekly report generation
+│   └── patterns.py     # Cross-day pattern detection + friction trends
+├── replacement/        # Workflow replacement engine
+│   └── engine.py       # LLM-powered proposals + Agenticom YAML
+├── api/                # FastAPI endpoints (Phase 4)
+└── cli/                # Click CLI — 16 commands
+    └── main.py
+```
+
+## CLI Commands (16 total)
+```bash
+workflowx status      # Connection status, storage stats
+workflowx capture     # Read events from Screenpipe/ActivityWatch
+workflowx analyze     # LLM intent inference on sessions
+workflowx validate    # Answer classification questions
+workflowx report      # Daily/weekly workflow report
+workflowx propose     # Generate replacement proposals
+
+# Phase 2
+workflowx patterns    # Detect recurring high-friction workflows
+workflowx trends      # Weekly friction trajectory
+workflowx export      # JSON/CSV export
+workflowx mcp         # Start MCP server for Claude/Cursor
+
+# Phase 3
+workflowx adopt       # Mark a replacement as adopted, start ROI tracking
+workflowx measure     # Measure actual ROI of adopted replacements
+workflowx dashboard   # Generate static HTML ROI dashboard
+workflowx serve       # Live dashboard server at localhost:7788 (Update button)
+workflowx demo        # Full pipeline on synthetic data (no Screenpipe needed)
+
+# Daemon
+workflowx daemon start   # Install launchd agent + start (auto-restarts on login)
+workflowx daemon stop    # Stop daemon + remove launchd plist
+workflowx daemon status  # Job history table + upcoming schedule
+workflowx daemon run     # Internal: raw event loop (called by launchd)
+```
+
+## Daemon Schedule
+```
+health:  every 5 min        — Screenpipe liveness; notifies if frames drop
+capture: 12:55·17:55·22:55  — rolls up last 4h of Screenpipe events (every day)
+analyze: 13:00·18:00·23:00  — LLM inference; event-triggers propose on HIGH/CRITICAL
+measure: 07:00 daily        — adaptive ROI (weekly ≤30 days, monthly after)
+brief:   08:30 weekdays     — morning notification: friction summary + pending actions
+```
+
+State: `~/.workflowx/daemon_state.json`
+PID:   `~/.workflowx/daemon.pid`
+Log:   `~/.workflowx/daemon.log`
+
+## Common Dev Commands
+```bash
+make install-dev      # Install with all deps + dev tools
+make test             # Run all tests with coverage
+make test-fast        # Run unit tests only, stop on first failure
+make lint             # Ruff + mypy
+make format           # Auto-format
+make check            # lint + test (run before PR)
+```
+
+## Architecture Principles
+1. **Don't build capture** — use Screenpipe/ActivityWatch. Our value is intelligence.
+2. **Local-first** — all data stays on device. No cloud requirement.
+3. **Models are the contract** — everything flows through Pydantic models in models.py
+4. **LLM calls are isolated** — only intent.py and engine.py call LLMs
+5. **Daemon logic is pure** — scheduling/trigger functions (next_fire_time, should_measure,
+   should_propose) have zero I/O and are 100% unit-testable without asyncio or mocking
+6. **Measure everything** — without before/after ROI, we're just another advice tool
+
+## Testing
+- 134 tests in `tests/unit/` — fast, no external deps, no LLM calls
+- `tests/integration/` — may require Screenpipe DB or LLM API key
+- Always run `make test-fast` before committing
+- Test files: test_models, test_clusterer, test_config, test_storage, test_storage_v2,
+  test_reporter, test_patterns, test_measurement, test_export, test_dashboard, test_daemon
+
+## Key Design Decisions
+- **Screenpipe as primary capture**: MIT licensed, 12.6k stars, cross-platform
+- **Session gap = 5 min**: Configurable. >5 min between events = new session
+- **Friction = context switches / minute**: Simple heuristic, validated by user feedback
+- **Classification questions**: When inference confidence < 0.7, ask ONE question
+- **Agenticom integration**: Replacement engine generates workflow YAML
+- **Pattern detection**: Greedy clustering by intent similarity (SequenceMatcher ≥ 0.55)
+- **ROI measurement**: Compare pre-adoption vs post-adoption weekly minutes for same intent
+- **MCP server**: 5 tools (sessions, friction, patterns, trends, roi) via FastMCP
+- **Daemon scheduling**: next_fire_time() scans 8 days forward; weekdays_only=True for
+  brief, False for capture/analyze (late-night work happens on weekends too)
+- **Adaptive measure cadence**: weeks_tracked < expected; weekly ≤30d, monthly >30d
+- **Propose dedup**: per session ID, pruned after 30 days
+
+## PR Workflow
+1. Branch from `main`
+2. `make check` must pass
+3. Add tests for new logic
+4. Atomic commits: one concern per commit

CONTRIBUTING.md

@@ -0,0 +1,74 @@
+# Contributing to WorkflowX
+
+We welcome contributions. Here's how to get started fast.
+
+## Setup (2 minutes)
+
+```bash
+git clone https://github.com/wjlgatech/workflowx.git
+cd workflowx
+python -m venv .venv && source .venv/bin/activate
+make install-dev
+make test
+```
+
+If tests pass, you're ready.
+
+## What to Work On
+
+Check [Issues](https://github.com/wjlgatech/workflowx/issues) for tasks tagged:
+- `good-first-issue` — small, well-scoped, great for first contribution
+- `help-wanted` — we need your help here
+- `capture-adapter` — new data source adapters (ActivityWatch, WakaTime, etc.)
+- `inference` — improving intent inference accuracy
+- `replacement` — workflow replacement engine work
+
+## How to Contribute
+
+### 1. Pick an issue or propose one
+Comment on an issue to claim it, or open a new one describing what you want to build.
+
+### 2. Branch and build
+```bash
+git checkout -b your-feature
+# write code
+make check   # must pass
+```
+
+### 3. Submit a PR
+- Keep PRs focused (one concern per PR)
+- Add tests for new logic
+- Update CLAUDE.md if you change architecture
+
+### 4. Review
+We review PRs within 48 hours. Expect direct, constructive feedback.
+
+## Code Style
+
+- Python 3.10+, type hints everywhere
+- Pydantic models for data contracts
+- structlog for logging
+- Ruff for linting + formatting
+- Tests in `tests/unit/` (fast) or `tests/integration/` (external deps)
+
+## Architecture Rules
+
+1. **Capture adapters are thin** — they convert external data to `RawEvent`. No business logic.
+2. **Models are the contract** — if you need a new data shape, add it to `models.py` first.
+3. **LLM calls are isolated** — only `inference/intent.py` talks to LLMs. Everything else is deterministic.
+4. **Privacy by default** — no data leaves the device. No cloud calls except explicit LLM inference.
+
+## Adding a New Capture Adapter
+
+Want to add support for ActivityWatch, WakaTime, or another tool?
+
+1. Create `src/workflowx/capture/your_source.py`
+2. Implement a class with `read_events(since, until, limit) -> list[RawEvent]`
+3. Add tests in `tests/unit/test_your_source.py`
+4. Add optional deps to `pyproject.toml` under `[project.optional-dependencies]`
+
+That's it. The inference layer doesn't care where events come from.
+
+## Questions?
+
+Open an issue or reach out to [@wjlgatech](https://github.com/wjlgatech).

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Paul Jialiang Wu
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.