• Every import phase is gated on user consent (ask-user pattern) before proceeding.
• Google/social API access goes through ClawVisor. The agent never holds raw OAuth tokens or API keys. This is a safety requirement, not a preference. ClawVisor vaults credentials, enforces task-scoped authorization, logs every API call, and requires human approval for destructive operations. If the user doesn't want ClawVisor, the only safe alternative is offline file exports (Google Takeout, Twitter archive download).
• Each phase is independently valuable — the user can stop after any phase and still have a useful brain.
• Progress is tracked in

  ~/.gbrain/cold-start-state.json

  so interrupted sessions can resume.
• Entity detection and cross-linking run on every import, not as a separate pass.

• GBrain installed and initialized (

  gbrain doctor --json

  all green)
• Brain repo cloned and synced
• Agent has terminal access and can run

  gbrain

  CLI commands

Safety boundary: An AI agent with raw OAuth tokens to your Gmail, Calendar, and Contacts is an uncontrolled attack surface. One prompt injection, one malicious tool call, and your entire Google account is exposed. ClawVisor eliminates this risk class entirely.

• Credential vaulting — agent sees shadow tokens, never real secrets
• Task-scoped authorization — each workflow declares exactly what it needs
• Audit trail — every API call logged with metadata (who, what, when)
• Human approval gates — destructive operations (send email, modify calendar) require your explicit approval
• Multi-service — Gmail, Calendar, Contacts, Drive, GitHub, iMessage from one gateway
• Revocation — disable the agent's access in one click, no token rotation needed

1. Sign up at app.clawvisor.com
2. Create an agent in the dashboard, copy the agent token
3. Set environment variables:
   bash

   gbrain config set clawvisor_url "https://app.clawvisor.com"
   gbrain config set clawvisor_agent_token "<token>"

4. Activate Google services (Gmail, Calendar, Contacts) in the dashboard
5. Create a standing task with expansive scope:

   "Full brain bootstrapping: read emails, calendar events, and contacts to populate knowledge base. List, read, and search across all connected accounts."

6. Save the standing task ID:
   bash

   gbrain config set clawvisor_task_id "<task_id>"

• Phase 1 (markdown/Obsidian) — works without any API access
• Phase 5 (conversation exports) — works from downloaded JSON files
• Phase 6 (X/Twitter) — works from downloaded archive
• Phase 7 (file archives) — works from local files
• Phase 8 (meeting transcripts) — works from exported transcripts

"No problem. We'll skip the Google imports for now and work with file-based sources. You can set up ClawVisor anytime to unlock Contacts, Calendar, and Gmail imports safely."

• Run link extraction:

  gbrain extract links --source db

• Run timeline extraction:

  gbrain extract timeline --source db

• Start embeddings:

  gbrain embed --stale

  (runs in background)

Track progress:

bash

echo '{"phase_1_complete": true, "pages_imported": N}' > ~/.gbrain/cold-start-state.json

1. Filter out noise — skip contacts with no name, no email, or that are clearly automated (noreply@, no-reply@, support@, notifications@)
2. Check brain first —

   gbrain search "name"

   to avoid duplicates
3. Create people/ page with:
   • Name, email(s), phone(s), company, title
   • Source attribution:

     [Source: Google Contacts, YYYY-MM-DD]

   • Any notes from the contact as initial context
4. Link to company — if the contact has an organization, create/update the company page and link the person to it

"Here's what a contact page looks like. Want me to continue with the rest, or adjust the format first?"

1. Look up each attendee in the brain (they should exist from Phase 2)
2. Add a timeline entry to their page: met at [event title] on [date]
3. If an attendee has no brain page and appears in 3+ events, create one
4. Link attendees who appear in the same meeting

1. Sent mail (last 30 days) — who the user actively communicates with
2. Starred/important emails — user-curated signal
3. Threads with 3+ replies — active conversations worth tracking
4. Emails from people already in the brain — enrichment, not cold import

1. Entity detection — extract people, companies mentioned
2. Update people pages — add communication context to timeline
3. Create meeting pages — if the email is a meeting summary or follow-up
4. Skip noise — newsletters, automated notifications, marketing

• noreply@, no-reply@, notifications@, support@, mailer-daemon@
• Unsubscribe-heavy senders (marketing)
• GitHub/Jira/Linear notification emails
• Calendar invites (already captured in Phase 3)

• Direct emails from people in the brain
• Starred/flagged emails
• Emails the user sent (their words are highest-value signal)

• ChatGPT: Settings → Data Controls → Export →

  conversations.json

• Claude: Download from claude.ai conversation history
• Perplexity: Export from settings

1. Assess significance (1-5 scale):
   • 1 = Pure utility (how-tos, quick lookups) → skip or minimal page
   • 2 = Minor context → 1-paragraph note
   • 3 = Notable (reveals interests, building something) → full page
   • 4 = Important (deep personal processing, strategic thinking) → rich page
   • 5 = Defining (identity work, breakthrough insights) → full treatment
2. Extract entities — people, companies, concepts discussed
3. Capture original thinking — the user's exact phrasing is the signal. Never paraphrase.
4. File by primary subject — not in a "conversations/" dump. A conversation about a person goes to people/, about a concept goes to concepts/, etc.

1. Twitter data export (Settings → Your Account → Download Archive)
   • Contains all tweets, likes, DMs, bookmarks
2. Live API (if available) — recent tweets and engagement
3. Bookmarks — curated signal, high value

• Original tweets → capture with full context, extract entities
• Quote tweets → capture the user's commentary + the source tweet
• Threads → reconstruct as a single narrative
• Bookmarks → high-signal curation, import with tags
• Likes — low signal, skip unless the user wants them

archive-crawler

• Crawling directory structures
• Filtering for high-value content (user's own writing, not installers)
• Text extraction from PDFs, images (OCR), documents
• Entity extraction and brain page creation

Safety gate: Archive crawling can be slow and create many pages. Always start with a scan-only pass:

bash

gbrain archive-crawler --scan-only --path /path/to/archive

Show the user the manifest before proceeding with full ingestion.

• Local directories (Dropbox sync folder, Google Drive, old hard drives)
• Cloud storage (Backblaze B2, S3) via mounted paths
• Email archives (PST, mbox, EML, Google Takeout)
• Data exports (LinkedIn, Facebook, etc.)

meeting-ingestion

• Always pull the complete transcript, not just the AI summary
• Entity propagation is MANDATORY — every attendee gets a timeline update
• A meeting is NOT fully ingested until all entity pages are updated

1. Verify brain health:
   bash

   gbrain doctor --json
   gbrain stats

2. Test retrieval:
   bash

   gbrain query "who do I meet with most often?"
   gbrain query "what am I working on?"
   gbrain search "<person from contacts>"

3. Set up live sync (if not already):
   • Calendar: daily cron
   • Email: periodic sweep (4-8 hours)
   • X: daily ingest
   • Brain repo:

     gbrain sync --repo <path>

     every 5-30 minutes
4. Track state:
   json

   // ~/.gbrain/cold-start-state.json
   {
     "started": "2026-01-15T10:00:00Z",
     "credential_gateway": "clawvisor",
     "phases_completed": [1, 2, 3, 4],
     "phases_skipped": [6, 7],
     "total_pages_created": 847,
     "total_entities_linked": 1203,
     "next_phase": 5
   }

5. Tell the user what to do next:

   "Your brain has N pages across people, calendar, email, and conversations. Live sync is configured for [sources]. From here:

   • The signal-detector captures entities from every conversation
   • The briefing skill can compile daily context
   • The executive-assistant pattern handles email triage
   • Say 'enrich [person]' to deep-dive any contact"

• Giving the agent raw OAuth tokens. This is the #1 anti-pattern. An agent with raw Gmail/Calendar tokens is an uncontrolled attack surface — one prompt injection and your entire Google account is exposed. Use ClawVisor. If the user declines ClawVisor, skip to offline imports. Never offer direct OAuth as a fallback.
• Bulk importing everything without filtering. The brain is for signal, not noise. Filter out automated senders, marketing emails, utility conversations.
• Importing without entity cross-linking. Every import should detect entities and update existing brain pages. Isolated imports don't compound.
• Not gating on user consent. Every phase should be presented as a choice. The user may not want their DMs or therapy conversations imported.
• Importing everything at significance 1. Not every conversation is worth a brain page. Use the significance scale and skip utility content.
• Creating people pages for automated senders. Sentry, GitHub notifications, newsletter platforms are not people. Filter by the rules in Phase 4.

1. Read

   ~/.gbrain/cold-start-state.json

2. Skip completed phases
3. Resume from

   next_phase

4. The user doesn't have to repeat credential setup or re-import completed sources

• search

  — check for existing pages before creating

• query

  — hybrid search for entity deduplication

• get_page

  — read existing pages for merge decisions

• put_page

  — create and update brain pages

• add_link

  — cross-reference entities

• add_timeline_entry

  — record events on entity timelines

• sync_brain

  — sync changes to the index after each phase