Files
openhuman/gitbooks
c9f293d8ec test(e2e): wait for route readiness
## Summary

- Replaces the fixed post-hash `browser.pause(2_000)` with a route readiness wait.
- `navigateViaHash()` now waits for the target hash, `document.readyState === "complete"`, and a mounted React root before returning.
- `walkOnboarding()` now waits for `#/home` and a Home-page marker after the onboarding next button unmounts.
- Documents the navigation-readiness pattern in the E2E guide.

## Problem

- #1864 reports a first-navigation race after onboarding: the hash changes, but the target panel can be empty because React has not settled yet.
- The old helper returned after a fixed pause, so specs could start looking for panel text before the routed view mounted.

## Solution

- Add `waitForHashRouteReady()` to make hash navigation wait on concrete browser/app signals.
- Add `waitForPostOnboardingHome()` so the onboarding walker does not hand control back until Home is actually ready.
- Throw navigation readiness failures immediately instead of hiding them behind a later text timeout.

## Submission Checklist

- [x] Tests added or updated (happy path + at least one failure / edge case) per [Testing Strategy](../gitbooks/developing/testing-strategy.md#failure-path-requirement) - helper behavior tightened; E2E suite is the exercising path.
- [x] **Diff coverage >= 80%** - N/A locally: E2E helper/doc change; CI E2E jobs are authoritative.
- [x] Coverage matrix updated - N/A: E2E helper behavior change, no feature row added/removed/renamed.
- [x] All affected feature IDs from the matrix are listed in the PR description under `## Related` - N/A: no matrix feature ID applies.
- [x] No new external network dependencies introduced (mock backend used per [Testing Strategy](../gitbooks/developing/testing-strategy.md#mock-policy))
- [x] Manual smoke checklist updated if this touches release-cut surfaces ([`docs/RELEASE-MANUAL-SMOKE.md`](../docs/RELEASE-MANUAL-SMOKE.md)) - N/A: no release-cut surface.
- [x] Linked issue closed via `Closes #NNN` in the `## Related` section

## Impact

- Runtime/user impact: none; test helper only.
- E2E impact: hash navigation and post-onboarding transitions now wait on real readiness signals instead of fixed sleeps.
- Failure mode improves: route readiness failures surface at navigation time with the target hash in the error.

## Related

- Closes #1864
- Follow-up PR(s)/TODOs: N/A

---

## AI Authored PR Metadata (required for Codex/Linear PRs)

### Linear Issue
- Key: N/A
- URL: N/A

### Commit & Branch
- Branch: `codex/1864-e2e-navigation-readiness`
- Commit SHA: `15f56af3c6c865fbd322010d25b047a998ebd964`

### Validation Run
- [x] `pnpm --filter openhuman-app exec prettier --check test/e2e/helpers/shared-flows.ts` - passed
- [x] `pnpm typecheck` - passed
- [x] Focused tests: N/A, E2E helper change not run locally
- [x] Rust fmt/check (if changed): `cargo fmt --all --check` - passed; `git diff --check` - passed
- [x] Tauri fmt/check (if changed): N/A

### Validation Blocked
- `command:` full E2E rerun
- `error:` not run locally; requires built desktop app/Appium harness
- `impact:` remote E2E CI remains authoritative for the harness change

### Behavior Changes
- Intended behavior change: E2E helpers wait for route/onboarding readiness before specs continue.
- User-visible effect: none.

### Parity Contract
- Legacy behavior preserved: same routes and onboarding flow; only readiness timing changed.
- Guard/fallback/dispatch parity checks: existing text assertions remain in specs after helper navigation.

### Duplicate / Superseded PR Handling
- Duplicate PR(s): N/A
- Canonical PR: this PR
- Resolution (closed/superseded/updated): N/A


<!-- This is an auto-generated comment: release notes by coderabbit.ai -->
## Summary by CodeRabbit

* **Tests**
  * Enhanced E2E helpers for more reliable hash-based navigation and for stronger verification that onboarding completes and the Home page is fully settled.

* **Documentation**
  * Updated E2E testing guide with cross-platform navigation guidance recommending the hash navigation helper and noting post-onboarding Home-page readiness checks.

<!-- review_stack_entry_start -->

[![Review Change Stack](https://storage.googleapis.com/coderabbit_public_assets/review-stack-in-coderabbit-ui.svg)](https://app.coderabbit.ai/change-stack/tinyhumansai/openhuman/pull/2304?utm_source=github_walkthrough&utm_medium=github&utm_campaign=change_stack)

<!-- review_stack_entry_end -->
<!-- end of auto-generated comment: release notes by coderabbit.ai -->

Co-authored-by: aqilaziz <gonzes7@gmail.com>
Co-authored-by: Steven Enamakel <enamakel@tinyhumans.ai>
2026-05-20 16:52:19 -07:00
..
2026-05-10 02:52:14 +00:00
2026-05-20 16:44:35 -07:00
2026-05-09 00:17:29 -07:00
2026-05-14 05:40:41 +00:00

description, icon
description icon
Personal AI assistant for your desktop. Connects to 118+ services, builds a local-first memory of your life, self-reflects, and can interact with you over audio and video. diamond

Welcome to OpenHuman

OpenHuman is an open-source AI assistant designed to be the memory and doer for everything you do across your tools. Built on Rust + Tauri and licensed under GNU GPL3, it closes the gap between what AI models can do and what they actually know about you.

Every model in the world, all 200+ of them, shares the same fundamental limitation: they are stateless. You type a prompt, get a response, and the context evaporates. Even the ones with "memory" store a few bullet points. A few bullet points is a sticky note, not intelligence.

OpenHuman solves this with a stack that's calmly, deliberately different:

  • A local-first Memory Tree. Every source you connect. Gmail, Slack, GitHub, Notion, your own notes, flows through a deterministic pipeline: canonical Markdown, ≤3k-token chunks, scored, folded into per-source / per-topic / per-day summary trees. Stored in SQLite on your machine. No vector-soup black box.
  • An Obsidian-style wiki on top of it. The same chunks the agent reasons over land as .md files in a vault you can open in Obsidian, browse, edit, and link by hand. Inspired by Karpathy's obsidian-wiki workflow. You can't trust a memory you can't read.
  • 118+ third-party integrations. One-click OAuth into Gmail, GitHub, Slack, Notion, Stripe, Calendar, Drive, Linear, Jira and more - no API keys to wire by hand, no plugin marketplace to navigate.
  • Auto-fetch. Every twenty minutes, OpenHuman pulls fresh data from every active connection and folds it into the Memory Tree without you asking, so the agent already has tomorrow's context this morning.
  • An agent built for big data. Smart token compression (TokenJuice) compacts verbose tool output before it ever enters the model's context, so sweeping through your last six months of email costs single-digit dollars. Automatic model routing sends each task to the right model - hint:reasoning to a frontier model, hint:fast to a cheap one, vision to vision - all under one subscription. Optional local AI via Ollama or LM Studio keeps supported workloads on-device.
  • Batteries included. A complete agent toolbelt is wired in by default: web search, a web-fetch scraper, a full coder toolset (filesystem, git, lint, test, grep), browser & computer control, cron & scheduling, memory tools, agent coordination for spawning sub-agents, and native voice - STT in, TTS out, mascot lip-sync, and a live Google Meet agent that joins meetings, transcribes them into your Memory Tree, and can speak back into the call. No "install a plugin to read files" friction.
  • Simple, UI-first. A clean desktop experience and short onboarding paths take you from install to a working agent in a few clicks - no config-first setup, no terminal required. The agent has a face: a desktop mascot that speaks, reacts to its surroundings, joins your Google Meets as a real participant, remembers you across weeks, and keeps thinking in the background even when you've stopped typing.

Together, these turn OpenHuman into something fundamentally different from a chatbot. It is an AI agent that consumes large amounts of personal data at low cost, maintains a persistent and evolving understanding of your world, and takes proactive actions on your behalf.

{% hint style="warning" %} OpenHuman is not AGI. But it is a meaningful architectural step closer, with better memory, better orchestration, and better tooling. {% endhint %}