Add database query CLI tool for development

Eliminate full timeline memory load: route committed queries to DB
fix(server): keep Claude model queries open
2026-10-28 12:12:47 +00:00 · 2026-03-25 20:39:08 +07:00 · 2026-03-25 20:39:08 +07:00 · 2026-03-25 20:39:08 +07:00 · 2026-03-25 20:39:08 +07:00 · 2026-03-25 20:39:08 +07:00
174 changed files with 14024 additions and 6176 deletions
@@ -124,7 +124,7 @@ jobs:
              release_type="release"
            fi
          else
-            release_type="draft"
+            release_type="release"
          fi
          echo "RELEASE_TYPE=$release_type" >> "$GITHUB_ENV"

@@ -230,7 +230,7 @@ jobs:
              release_type="release"
            fi
          else
-            release_type="draft"
+            release_type="release"
          fi
          echo "RELEASE_TYPE=$release_type" >> "$GITHUB_ENV"

@@ -339,7 +339,7 @@ jobs:
              release_type="release"
            fi
          else
-            release_type="draft"
+            release_type="release"
          fi
          echo "RELEASE_TYPE=$release_type" >> "$GITHUB_ENV"

@@ -1,45 +0,0 @@
-name: Fix Nix hash
-
-on:
-  push:
-    branches: [main]
-    paths:
-      - 'package.json'
-      - 'package-lock.json'
-  pull_request:
-    paths:
-      - 'package.json'
-      - 'package-lock.json'
-
-permissions:
-  contents: write
-
-jobs:
-  fix-nix-hash:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          ref: ${{ github.head_ref || github.ref }}
-          token: ${{ secrets.GITHUB_TOKEN }}
-
-      - uses: actions/setup-node@v4
-        with:
-          node-version: '22'
-          cache: 'npm'
-
-      - uses: cachix/install-nix-action@v31
-        with:
-          nix_path: nixpkgs=channel:nixos-unstable
-
-      - name: Fix lockfile and update hash
-        run: ./scripts/update-nix.sh
-
-      - name: Commit changes
-        run: |
-          git diff --quiet package-lock.json nix/package.nix && exit 0
-          git config user.name "github-actions[bot]"
-          git config user.email "github-actions[bot]@users.noreply.github.com"
-          git add package-lock.json nix/package.nix
-          git commit -m "fix: update lockfile signatures and Nix hash"
-          git push
@@ -1,59 +0,0 @@
-name: Nix Build
-
-on:
-  push:
-    branches: [main]
-    paths:
-      - 'nix/**'
-      - 'flake.nix'
-      - 'flake.lock'
-      - 'package.json'
-      - 'package-lock.json'
-      - 'packages/highlight/**'
-      - 'packages/server/**'
-      - 'packages/relay/**'
-      - 'packages/cli/**'
-  pull_request:
-    branches: [main]
-    paths:
-      - 'nix/**'
-      - 'flake.nix'
-      - 'flake.lock'
-      - 'package.json'
-      - 'package-lock.json'
-      - 'packages/highlight/**'
-      - 'packages/server/**'
-      - 'packages/relay/**'
-      - 'packages/cli/**'
-
-permissions:
-  contents: read
-
-jobs:
-  build:
-    runs-on: ubuntu-latest
-    continue-on-error: false
-    steps:
-      - uses: actions/checkout@v4
-
-      - uses: cachix/install-nix-action@v31
-        with:
-          nix_path: nixpkgs=channel:nixos-unstable
-
-      - name: Build Nix package
-        run: nix build .#default -o result
-
-      - name: Verify lockfile is complete
-        # npm silently omits resolved/integrity fields in workspace monorepos.
-        # Nix needs them for offline builds. See https://github.com/npm/cli/issues/4460
-        run: |
-          node scripts/fix-lockfile.mjs package-lock.json
-          git diff --exit-code package-lock.json || {
-            echo "ERROR: package-lock.json has missing resolved/integrity fields."
-            echo "This is a known npm bug: https://github.com/npm/cli/issues/4460"
-            echo "Run 'node scripts/fix-lockfile.mjs' and commit the result."
-            exit 1
-          }
-
-      - name: Check npmDepsHash is up to date
-        run: ./scripts/update-nix.sh --check
@@ -1,58 +1,5 @@
 # Changelog

-## 0.1.36 - 2026-03-27
-
-### Fixed
- Fixed Windows drive-letter path handling across the codebase.
- Fixed stale Nix hash with automatic lockfile-change detection.
-
-### Added
- Added metrics collection and terminal performance tests.
-
-## 0.1.35 - 2026-03-26
-
-### Improved
- Faster app startup by redirecting to the welcome screen immediately and showing host connection status inline.
- Codex file deletions now display correctly as removed lines in diffs.
- OpenCode questions are now surfaced in the permission UI.
-
-### Fixed
- Fixed queued prompt dispatch after idle transition.
- Replaced bash-only `mapfile` with a portable `while-read` loop in the chat script.
-
-### Added
- Added support for Nix and NixOS installation.
-
-## 0.1.34 - 2026-03-25
-
-### Added
- Added `paseo archive` as a top-level alias for `paseo agent archive`.
- Added the `PASEO_AGENT_ID` environment variable for Claude and Codex agents.
- Added a redesigned command autocomplete with a detail card and dropdown styling.
- Linked Android download surfaces to the Google Play Store.
-
-### Improved
- Autonomous turns now complete gracefully on interrupt instead of being canceled.
- Thinking/model selection now always resolves to a real option instead of showing a generic Default choice.
- Restored per-provider form preferences and removed the Auto model fallback.
- Improved Codex activity logs with clearer tool-call summaries.
- Reduced unnecessary re-renders in the agent panel and input area for smoother interaction.
- Improved chat transcript readability.
-
-### Fixed
- Fixed `paseo send --no-wait` not taking effect.
- Fixed stale abort results contaminating replacement turns after an interrupt.
- Fixed Claude interrupt handling and autonomous wake reliability.
- Fixed nested Claude Code session detection and provider availability checks.
- Fixed agent input focus scoping across panels.
- Fixed terminal snapshot ordering when subscribing.
- Fixed `chat read --since` to accept message IDs.
- Fixed keyboard pane focus syncing with the active panel.
- Fixed assistant text selection on web.
- Fixed archived-agent notifications still appearing in chat rooms.
- Fixed the attach-images button interaction in the message composer.
- Pruned wrong-platform native binaries from Electron desktop builds.
-
 ## 0.1.33 - 2026-03-23

 ### Fixed
@@ -35,6 +35,8 @@ npm run dev                          # Start daemon + Expo in Tmux
 npm run cli -- ls -a -g              # List all agents
 npm run cli -- daemon status         # Check daemon status
 npm run typecheck                    # Always run after changes
+npm run db:query                     # Show DB table row counts
+npm run db:query -- "SELECT ..."     # Run arbitrary SQL against PGlite
 ```

 See [docs/DEVELOPMENT.md](docs/DEVELOPMENT.md) for full setup, build sync requirements, and debugging.
@@ -4,88 +4,40 @@

 <h1 align="center">Paseo</h1>

-<p align="center">One interface for all your Claude Code, Codex and OpenCode agents.</p>
+<p align="center">One interface for all your coding agents.</p>

 <p align="center">
-  <img src="https://paseo.sh/hero-mockup.png" alt="Paseo app screenshot" width="100%">
-</p>
-
-<p align="center">
-  <img src="https://paseo.sh/mobile-mockup.png" alt="Paseo mobile app" width="100%">
+  <img src="https://paseo.sh/paseo-mockup.png" alt="Paseo app screenshot" width="100%">
 </p>

 ---

 Run agents in parallel on your own machines. Ship from your phone or your desk.

- **Self-hosted:** Agents run on your machine with your full dev environment. Use your tools, your configs, and your skills.
- **Multi-provider:** Claude Code, Codex, and OpenCode through the same interface. Pick the right model for each job.
- **Voice control:** Dictate tasks or talk through problems in voice mode. Hands-free when you need it.
- **Cross-device:** iOS, Android, desktop, web, and CLI. Start work at your desk, check in from your phone, script it from the terminal.
- **Privacy-first:** Paseo doesn't have any telemetry, tracking, or forced log-ins.
+- **Self-hosted** — Agents run on your machine with your full dev environment. Use your tools, your configs, and your skills.
+- **Multi-provider** — Claude Code, Codex, and OpenCode through the same interface. Pick the right model for each job.
+- **Voice control** — Dictate tasks or talk through problems in voice mode. Hands-free when you need it.
+- **Cross-device** — iOS, Android, desktop, web, and CLI. Start work at your desk, check in from your phone, script it from the terminal.

 ## Getting Started

-### Desktop app
-
-Download from [paseo.sh/download](https://paseo.sh/download) or the [GitHub releases page](https://github.com/getpaseo/paseo/releases). The app bundles its own daemon, so there's nothing else to install. It can also connect to daemons running on other machines.
+Download the desktop app from [paseo.sh](https://paseo.sh) or the [GitHub releases page](https://github.com/getpaseo/paseo/releases) — it bundles the daemon so there's nothing else to install.

 ### Headless / server mode

-Run the daemon on any machine:
+To run the daemon on a remote or headless machine:

 ```bash
 npm install -g @getpaseo/cli
 paseo
 ```

-Then connect from any client — desktop, web, mobile, or CLI. See [paseo.sh/download](https://paseo.sh/download) for all options.
+Then connect from the desktop app, mobile app, or CLI.

 For full setup and configuration, see:
 - [Docs](https://paseo.sh/docs)
 - [Configuration reference](https://paseo.sh/docs/configuration)

-## CLI
-
-Everything you can do in the app, you can do from the terminal.
-
-```bash
-paseo run --provider claude/opus-4.6 "implement user authentication"
-paseo run --provider codex/gpt-5.4 --worktree feature-x "implement feature X"
-
-paseo ls                           # list running agents
-paseo attach abc123                # stream live output
-paseo send abc123 "also add tests" # follow-up task
-
-# run on a remote daemon
-paseo --host workstation.local:6767 run "run the full test suite"
-```
-
-See the [full CLI reference](https://paseo.sh/docs/cli) for more.
-
-## Orchestration skills (Unstable)
-
-Experimental skills that teach agents how to use the Paseo CLI to orchestrate other agents. I am updating these very frequently as I learn new things, expect changes without notice, might be coupled to my own setup, use at your own risk.
-
-```bash
-npx skills add getpaseo/paseo
-```
-
-Then use them in any agent conversation:
-
-```bash
-# Use handoff when you discuss something with an agent but want another one to implement.
-# I use this to plan with Claude and then handoff to Codex to implement.
-/paseo-handoff hand off the authentication fix to codex 5.4 in a worktree
-
-# Use loops when you have clear acceptance criteria (aka Ralph loops).
-/paseo-loop loop a codex agent to fix the backend tests, use sonnet to verify, max 10 iterations
-
-# Orchestrator teaches the agent how to create teams and manage them via a chat room.
-# Very opinionated and expects both Codex and Claude to work.
-/paseo-orchestrator spin up a team to implement the database refactor, use chat to coordinate. use claude to plan and codex to implement and review
-```
-
 ## Development

 Quick monorepo package map:
@@ -105,12 +57,8 @@ npm run dev
 # run individual surfaces
 npm run dev:server
 npm run dev:app
-npm run dev:desktop
 npm run dev:website

-# build the daemon
-npm run build:daemon
-
 # repo-wide checks
 npm run typecheck
 ```
@@ -51,4 +51,4 @@ Paseo wraps agent CLIs (Claude Code, Codex, OpenCode) but does not manage their

 ## Reporting vulnerabilities

-If you discover a security vulnerability, please report it privately by emailing hello@moboudra.com. Do not open a public issue.
+If you discover a security vulnerability, please report it privately by emailing mo@faro.so. Do not open a public issue.
@@ -35,6 +35,24 @@ In worktrees or with `npm run dev`, ports may differ. Never assume defaults.

 Check `$PASEO_HOME/daemon.log` for trace-level logs.

+### Database queries
+
+Run arbitrary SQL against the PGlite database:
+
+```bash
+# Show table row counts
+npm run db:query
+
+# Run any SQL
+npm run db:query -- "SELECT agent_id, title, last_status FROM agent_snapshots"
+npm run db:query -- "SELECT agent_id, seq, item_kind FROM agent_timeline_rows ORDER BY committed_at DESC LIMIT 10"
+
+# Point at a specific DB directory
+npm run db:query -- --db /path/to/db "SELECT ..."
+```
+
+Auto-detects the running dev daemon's database from `/tmp/paseo-dev.*`, `PASEO_HOME`, or `~/.paseo/db`.
+
 ## Build sync gotchas

 ### Relay → Daemon
@@ -15,8 +15,8 @@ If asked to "release paseo" without specifying major/minor, treat it as a patch
 ## Manual step-by-step

 ```bash
-npm run release:check        # Typecheck, build, dry-run pack
 npm run version:all:patch    # Bump version, create commit + tag
+npm run release:check        # Validate release
 npm run release:publish      # Publish to npm
 npm run release:push         # Push HEAD + tag (triggers CI workflows)
 ```
@@ -25,7 +25,6 @@ npm run release:push         # Push HEAD + tag (triggers CI workflows)

 ```bash
 npm run draft-release:patch    # Bump, push tag, create draft GitHub Release
-# ... test builds from the draft release assets ...
 npm run release:finalize       # Publish npm, promote draft to published
 ```

@@ -33,7 +32,6 @@ npm run release:finalize       # Publish npm, promote draft to published
 - `release:finalize` publishes npm and promotes the same draft release
 - Use the same semver tag for both; don't cut a second tag
 - Desktop assets now come from the Electron package at `packages/desktop`
- **Do NOT create a changelog entry for drafts.** The changelog entry is written only when finalizing. The website parses `CHANGELOG.md` to determine the latest published version for download links — adding an entry for a draft will point the homepage at untested assets.

 ## Fixing a failed release build

@@ -64,23 +62,12 @@ This ensures the checkout ref matches the actual code on `main` with the fix inc
 - `release:prepare` refreshes workspace `node_modules` links to prevent stale types
 - `npm run dev:desktop` and `npm run build:desktop` target the Electron desktop package in `packages/desktop`
 - If `release:publish` partially fails, re-run it — npm skips already-published versions
- The website parses the first `## X.Y.Z` heading in `CHANGELOG.md` to determine the download version. This is why changelog entries must only be added at finalization, not during drafts.
-
-## Changelog format
-
-The website depends on the changelog to determine the latest download version. The heading format **must** be strictly followed:
-
-```
-## X.Y.Z - YYYY-MM-DD
-```
-
-No prefix (`v`), no extra text. The parser matches the first `## X.Y.Z` line to extract the version. A malformed heading will break download links on the homepage.
+- Website Mac download CTA URL derives from `packages/website/package.json` version at build time

 ## Completion checklist

 - [ ] Update `CHANGELOG.md` with user-facing release notes (features, fixes — not refactors)
- [ ] Verify the changelog heading follows strict `## X.Y.Z - YYYY-MM-DD` format
- [ ] `npm run release:patch` (or `release:finalize` for drafts) completes successfully
+- [ ] `npm run release:patch` completes successfully
 - [ ] GitHub `Desktop Release` workflow for the `v*` tag is green
 - [ ] GitHub `Android APK Release` workflow for the same tag is green
 - [ ] EAS `release-mobile.yml` workflow for the same tag is green
@@ -0,0 +1,848 @@
+# Storage Revamp Plan
+
+Status: working implementation plan
+
+This document is meant to guide implementation and review. It captures the decisions that have already converged, names the sequencing and test gates that should not be skipped, and leaves open the product and implementation details that are still legitimately undecided.
+
+## Goals and scope
+
+The storage revamp moves Paseo from a mixed JSON plus in-memory model to an explicit storage layer backed by Drizzle and PGlite.
+
+In scope:
+
+- durable storage for project records
+- durable storage for workspace records
+- durable storage for agent snapshot metadata
+- durable storage for committed agent timeline history
+- a simplified timeline contract: committed canonical history vs provisional live updates
+- removal of `epoch`/`reset`/projection-heavy timeline recovery paths
+- migration and cutover from existing JSON-backed Paseo homes where source data actually exists
+
+## Non-goals
+
+Out of scope for this plan:
+
+- migrating config, keypairs, server identity, or push-token files into the DB
+- persisting raw provider deltas, chunk streams, or other transport-only live updates
+- designing a remote/cloud database story beyond keeping the schema portable
+- committing durable reasoning history in v1 unless product explicitly asks for it later
+- preserving legacy timeline semantics such as `epoch`, projection metadata, or provider-history rehydrate on refresh/load
+
+## Current state and migration hazards
+
+Today the server persists three different kinds of state in three different ways:
+
+- projects in `projects/projects.json`
+- workspaces in `projects/workspaces.json`
+- agent snapshots in `agents/{cwd}/{agent-id}.json`
+
+Committed timeline history is different. It is still effectively an in-memory `AgentManager` concern:
+
+- rows live in `agent.timelineRows`
+- sequence numbers are assigned in memory
+- retention trimming can drop older rows
+- `fetchAgentTimeline` still carries `epoch`, `reset`, `gap`, projection mode, and seq-range metadata to compensate for that model
+
+There are also two migration hazards that should be treated as foundation work, not cleanup:
+
+1. Agent snapshot persistence is split across multiple writers.
+   `attachAgentStoragePersistence()` flushes `agent_state` snapshots, while `Session` also writes agent records directly for archive/unarchive and related flows. The storage revamp should collapse that into clearer ownership before the DB swap broadens the write surface.
+
+2. Agent load and refresh still depend on provider history hydration.
+   `Session.ensureAgentLoaded()` resumes or recreates a provider session and then calls `hydrateTimelineFromProvider()`. That makes refresh/load behavior depend on provider-managed history, creates replay and dedup complexity, and blocks a clean storage-owned timeline contract.
+
+The practical implication is that this is not just a database wiring task. The contract and ownership model have to be simplified first.
+
+## Converged decisions and contracts
+
+### Storage choice: Drizzle + PGlite
+
+This plan assumes Drizzle plus PGlite.
+
+Why this is the right default:
+
+- one Postgres-flavored schema and migration pipeline for local and future hosted storage
+- no native addon packaging burden in the Electron and local-daemon environment
+- Drizzle keeps the schema in TypeScript and fits the existing codebase style better than a heavier codegen-oriented ORM
+- PGlite is fast enough for Paseo's local CRUD and timeline query workload
+
+This does not lock the project into every detail of local database lifecycle yet. It does lock the plan onto a Postgres-shaped schema and Drizzle-based migration workflow.
+
+### Storage boundary
+
+The goal is not a grand generic repository framework. The useful seams are:
+
+- `ProjectRegistry`
+- `WorkspaceRegistry`
+- `AgentSnapshotStore`
+- `AgentTimelineStore`
+- `WorkspaceReconciliationService`
+
+The refactor should preserve clear domain ownership:
+
+- project and workspace records stay distinct because reconciliation and placement logic are distinct
+- agent snapshot metadata stays separate from timeline history
+- filesystem reconciliation stays as a service over stored records, not an accidental side effect inside session code
+
+### Timeline contract
+
+The room has converged on a simplified contract:
+
+- `timeline` event with `seq` present means committed canonical history owned by Paseo storage
+- `timeline` event with no `seq` means provisional live-only state and is never returned by catch-up fetches
+- committed rows must already be in canonical display/history shape, not raw provider chunk shape
+- `fetch-after-seq` returns committed rows only
+- Phase 0 policy: reconnect does not use a subscribe-time provisional seed
+- if a turn is still active after reconnect, the client resumes from future live provisional updates only
+- provisional-seed ordering is therefore out of scope for Phase 0 until product explicitly chooses to add that policy
+- at most one active provisional assistant stream and one active provisional reasoning stream exist per turn
+- tool progress continues to correlate by existing `callId`
+- reasoning is live-only for v1 unless product explicitly changes that call later
+
+### Why `epoch` is removed
+
+`epoch` exists today because timeline identity is not fully owned by durable storage. It resets when the in-memory window is invalidated or rebuilt, and clients carry that reset logic in public protocol state.
+
+That is the wrong long-term contract for a DB-backed append-only history. Once committed history is storage-owned and no longer trimmed out from under clients:
+
+- catch-up can be `after seq`
+- published sequence numbers do not need to be rewritten
+- clients do not need `epoch`, `reset`, or projection-derived recovery metadata
+
+Removing `epoch` is not a cosmetic cleanup. It is the public sign that committed history is finally durable and stable.
+
+### Why refresh/load must not rehydrate provider history
+
+Provider history hydration made sense as a stopgap while Paseo did not own durable timeline history. It is now an obstacle.
+
+Refresh/load must stop rehydrating provider history because it:
+
+- makes the public history contract depend on provider-specific retention and replay behavior
+- forces user-message dedup rules and other replay suppression into server logic
+- creates ambiguity over whether a timeline row is provider-imported history or Paseo-owned committed history
+- makes reconnect behavior depend on re-importing old provider state instead of reading committed rows from storage
+
+The replacement contract is simpler:
+
+- refresh/load restores agent snapshot state from Paseo storage
+- committed history comes from `AgentTimelineStore`
+- provisional in-flight state, if any, is subscription-scoped and may be seeded once per subscription according to the chosen policy
+
+## Timeline consumption contract
+
+The client model is intentionally two-layered:
+
+- committed history is the durable tail, keyed by monotonically increasing `seq`
+- provisional live state is the transient head, carried by unsequenced `timeline` events
+
+The client keeps a committed cursor, not a provisional cursor. Provisional streaming never advances that committed cursor.
+
+### Client mental model
+
+The client stores:
+
+- the last committed `seq` it has accepted for a given agent
+- the committed history rows needed for the current view
+- any current provisional UI state for in-progress assistant, reasoning, or tool activity
+
+It does not store or reason about a second durable sequence space for provisional data.
+
+### `fetch-after-seq`
+
+`fetch-after-seq(agentId, seq)` means:
+
+- return committed canonical history rows with `seq > cursor`
+- never return provisional live state
+- never return raw chunk rows
+- preserve committed order
+
+If there are no committed rows after that cursor yet, the result is empty even if an in-progress message is still streaming live.
+
+### Subscribe-time provisional seed
+
+A subscribe-time provisional seed, if used by the chosen policy, is a one-time delivery of the current full provisional items for that subscription.
+
+It is not:
+
+- a historical replay of provider deltas
+- a second committed history fetch
+- a second sequence space
+
+If emitted, it must arrive before later provisional patch events for that subscription.
+
+Phase 0 chooses the simpler policy: no subscribe-time provisional seed for now.
+
+### Reconnect scenarios
+
+Concrete reconnect example:
+
+- the client has accepted committed history through `seq = 120`
+- the committed tail includes rows through `120`
+- the client UI also shows an in-progress assistant message in the provisional head
+- that provisional assistant message has no committed seq yet
+
+Case A: the assistant message finishes while the client is disconnected
+
+1. The client reconnects with last committed `seq = 120`.
+2. The client calls `fetch-after-seq(agentId, 120)`.
+3. The server returns committed row `121`, containing the full finalized assistant message.
+4. The client accepts row `121` into the durable tail and advances its committed cursor to `121`.
+5. The stale provisional assistant UI from before disconnect is dropped because the committed row has now superseded it.
+
+Case B: the assistant message has not finished by the time the client reconnects
+
+1. The client reconnects with last committed `seq = 120`.
+2. The client calls `fetch-after-seq(agentId, 120)`.
+3. The server may legitimately return nothing new yet, because committed row `121` does not exist yet.
+4. Live streaming resumes.
+5. In Phase 0, the client continues from fresh live updates only.
+6. When the assistant message finally completes, it becomes one committed row `121`.
+
+In both cases:
+
+- partial streaming before disconnect never advanced the committed cursor
+- `fetch-after-seq` is about committed history only
+- provisional streaming is transient UI state, not committed history
+
+If the daemon restarted or the agent is unloaded:
+
+- committed history still comes from `AgentTimelineStore`
+- the client can fetch committed history by seq without the provider session being active
+- provisional state is absent unless a new live subscription later seeds it
+
+### Replacement rule without a second sequence space
+
+The replacement rule is intentionally simple:
+
+- committed rows are authoritative durable history
+- provisional UI is best-effort and disposable
+- when a committed row arrives that corresponds to previously shown provisional state, the committed row becomes the durable representation and the provisional UI is cleared
+
+This simplicity depends on the agreed invariant that there is at most one active provisional assistant stream and one active provisional reasoning stream per turn.
+
+This avoids introducing `epoch`, a second durable sequence space, or provider-specific replay semantics.
+
+## Authority and ownership
+
+The storage revamp needs explicit authority boundaries so the model cannot drift during implementation.
+
+- `AgentTimelineStore` owns committed timeline authority
+- only the committed-history authority path may assign durable `seq`
+- provisional/live buffering is owned by the runtime/session path that is already handling live provider events; it is not owned by the DB
+- `AgentSnapshotStore` owns durable agent snapshot persistence
+- `WorkspaceReconciliationService` owns filesystem-vs-stored-workspace reconciliation
+- `ProjectRegistry` and `WorkspaceRegistry` own durable structured records for those domains
+- legacy structured-record import is a bootstrap path owned by the structured-record storage layer, not by ad hoc session code
+
+Practical implications:
+
+- providers do not assign committed seqs
+- clients do not infer committed seq advancement from provisional events
+- session code may read committed history, but it should not become an alternate authority for committed storage semantics
+
+## Interfaces and module boundaries
+
+These are design-level contracts, not implementation-level signatures.
+
+### `AgentSnapshotStore`
+
+Responsibilities:
+
+- read and write durable agent snapshot metadata
+- archive and unarchive snapshot records
+- list and fetch stored agent snapshots without requiring an active provider session
+
+Useful method shape:
+
+- `get(agentId)`
+- `list(filter?)`
+- `upsert(snapshotRecord)`
+- `archive(agentId, archivedAt)`
+- `unarchive(agentId)`
+
+### `AgentTimelineStore`
+
+Responsibilities:
+
+- append finalized committed history rows
+- fetch committed history by tail, before-seq, or after-seq queries
+- serve committed history for unloaded or restarted agents
+- guarantee ordered committed seq allocation per agent
+
+Useful method shape:
+
+- `appendCommitted(agentId, item, metadata?) -> committedRow`
+- `fetchTail(agentId, limit)`
+- `fetchBeforeSeq(agentId, beforeSeq, limit)`
+- `fetchAfterSeq(agentId, seq, limit?)`
+- `getLatestCommittedSeq(agentId)`
+
+Constraints:
+
+- no raw chunk rows in durable history
+- no provisional rows in durable history
+- seq assignment happens only here or in the narrow authority path directly behind it
+
+### `ProjectRegistry`
+
+Responsibilities:
+
+- store and fetch durable project records
+- upsert, archive, and list project records
+
+Useful method shape:
+
+- `get(projectId)`
+- `list(filter?)`
+- `upsert(projectRecord)`
+- `archive(projectId, archivedAt)`
+
+### `WorkspaceRegistry`
+
+Responsibilities:
+
+- store and fetch durable workspace records
+- upsert, archive, and list workspace records
+
+Useful method shape:
+
+- `get(workspaceId)`
+- `list(filter?)`
+- `upsert(workspaceRecord)`
+- `archive(workspaceId, archivedAt)`
+
+### `WorkspaceReconciliationService`
+
+Responsibilities:
+
+- own both targeted reconcile-on-register or placement-update checks and broader stale-workspace sweeps
+- compare durable workspace records against filesystem reality
+- mark stale or missing workspaces according to the chosen policy
+- keep reconciliation logic out of session orchestration code
+
+Useful method shape:
+
+- `reconcileTarget(workspaceId | cwd) -> reconcileResult`
+- `reconcileSweep() -> reconciliationResult`
+
+### Timeline-facing session/service seam
+
+One session-facing timeline contract is useful so the app/CLI path does not need to know storage internals.
+
+Responsibilities:
+
+- fetch committed history for initial view, older-history pagination, or reconnect
+- expose live subscription semantics
+- apply the committed-vs-provisional contract consistently for app and CLI consumers
+
+Useful method shape:
+
+- `fetchTail(agentId, limit)`
+- `fetchBeforeSeq(agentId, beforeSeq, limit)`
+- `fetchAfterSeq(agentId, seq, limit?)`
+- `subscribe(agentId, options?)`
+
+This seam is a consumer-facing contract exposed by the session layer so app and CLI callers do not need to know storage internals. It is not a second storage/service authority for committed timeline semantics.
+
+## DB design and query shape
+
+The plan does not need to freeze the final schema, but it should lock the query-driving shape.
+
+### Main tables expected
+
+- `projects`
+- `workspaces`
+- `agent_snapshots`
+- `agent_timeline_rows`
+
+### Fields that matter for core queries
+
+For `agent_timeline_rows`:
+
+- `agent_id`
+- committed `seq`
+- committed timestamp
+- canonical item payload
+- optional item kind or type discriminator only if it helps storage ergonomics without expanding the hot-path query surface
+
+For `agent_snapshots`:
+
+- `agent_id`
+- provider
+- cwd / workspace linkage
+- lifecycle/status metadata
+- timestamps needed for listing and resume decisions
+- archive state
+
+For `projects` and `workspaces`:
+
+- durable IDs
+- linkage fields
+- display fields
+- archive state
+- timestamps needed for reconciliation and listing
+
+### Main queries to support efficiently
+
+Hot-path:
+
+- fetch committed tail for an agent
+- fetch older committed history before a known seq for scrollback / pagination
+- fetch committed rows after a known seq for reconnect/catch-up
+- fetch committed history for an unloaded or restarted agent through the same per-agent tail/after-seq path
+- append one finalized committed row
+- list/fetch agent snapshots for UI and session bootstrap
+- list/fetch projects and workspaces for the app shell
+
+Cold-path:
+
+- legacy structured-record import
+- archive/unarchive and reconciliation sweeps
+
+### Likely indexes and why
+
+- unique ordered `(agent_id, seq)` constraint/index on timeline rows for per-agent seq uniqueness, ordered append, and after-seq fetch
+- index on agent snapshot status/update time for list views
+- index on workspace `project_id` for grouped workspace listing
+- index on archive state where it materially reduces active-record scans
+
+This is enough to guide implementation without prematurely optimizing secondary filters or analytics-style queries. Per-type filtering is not part of the required v1 hot path.
+
+### Not optimizing yet
+
+The v1 design is intentionally not optimizing for:
+
+- cross-agent global timeline queries
+- full-text search over timeline history
+- reasoning-history analytics
+- provider-specific chunk replay
+- multi-tenant or remote-hosted query patterns
+
+## Timeline query scenarios and invariants
+
+Primary timeline queries:
+
+### Fetch tail for initial view
+
+- input: `agentId`, `limit`
+- result: latest committed canonical rows only
+- invariant: tail fetch does not depend on an active provider session
+
+### Fetch after seq for reconnect/catch-up
+
+- input: `agentId`, last committed `seq`
+- result: committed canonical rows with greater seq
+- invariant: no provisional rows are returned
+- invariant: no gaps or duplicates appear when combined with resumed live streaming
+
+### Fetch before seq for older-history pagination
+
+- input: `agentId`, `beforeSeq`, `limit`
+- result: older committed canonical rows with `seq < beforeSeq`
+- invariant: older-history pagination uses the same committed-row contract as tail and after-seq reads
+- invariant: no provisional rows or raw chunk rows are returned
+
+### Fetch committed history for unloaded or restarted agent
+
+- input: `agentId`
+- result: committed history from storage
+- invariant: provider-history rehydrate is not required
+
+### Append finalized committed row
+
+- input: finalized logical history item
+- result: one committed row with one durable seq
+- invariant: no raw chunk rows are written as durable history
+
+Core invariants:
+
+- provisional streaming does not advance the committed seq cursor
+- durable history contains finalized canonical rows only
+- clients recover from disconnect by fetching committed rows after the last committed seq
+- if nothing finalized while disconnected, `fetch-after-seq` may return nothing and live streaming resumes
+- if something finalized while disconnected, the returned committed row supersedes stale provisional client UI
+- no gaps or duplicates are allowed across catch-up plus live resume
+
+## v1 design non-goals
+
+The design deliberately does not support these in v1:
+
+- durable reasoning history
+- historical backfill of timeline data that never existed in Paseo storage
+- provider-history rehydrate as a normal refresh/load mechanism
+- raw chunk durability
+- multiple simultaneous provisional assistant or reasoning streams beyond the agreed single-stream invariant
+
+## Phase plan
+
+Each phase below includes the required goals, sequencing, tests, exit gate, and suggested commit boundary. The phases are intentionally practical rather than over-detailed.
+
+Suggested commit boundaries are approximate. They are there to keep reviewable slices and clear gates, not to force an artificial commit count if two adjacent steps clearly belong together.
+
+### Phase 0: Contract and model cleanup before DB wiring
+
+Goal:
+Lock the public and internal timeline contract before introducing a new storage backend.
+
+What changes:
+
+- remove `epoch` from shared timeline cursor/message shapes
+- define committed-vs-provisional semantics around `timeline + optional seq`
+- remove projection-specific public response baggage such as `reset`, `projection`, seq-range collapse metadata, and related epoch gates
+- update server/session/app catch-up logic to use seq-backed committed history plus provisional head seeding
+- make reasoning explicitly live-only for v1
+- document and enforce the single-provisional-stream invariant per kind
+
+Dependencies:
+
+- none beyond the contract decisions already converged in the room
+
+Tests required:
+
+- shared message parsing tests for the simplified timeline payloads
+- app reducer tests for committed append, provisional merge, and reconnect without provisional seeding
+- session/WebSocket tests for `live -> disconnect -> fetch-after-seq -> subscribe -> resume`
+- explicit no-provisional-seed reconnect test proving that reconnect resumes from committed catch-up plus future live events only
+
+Exit gate:
+The client and server can exchange committed and provisional timeline updates without `epoch`, `reset`, or projection metadata, and all timeline catch-up tests pass with the new contract.
+
+Can happen in parallel:
+
+- shared message/schema cleanup
+- app reducer and bootstrap policy cleanup
+- server session fetch/subscribe cleanup
+
+Must stay sequential:
+
+- final protocol shape must settle before DB schema and timeline store work begin
+
+Suggested commit boundaries:
+
+- protocol and message schema cleanup
+- app/session reducer and catch-up logic cleanup
+- tests locking the new contract
+
+### Phase 1: Storage boundary refactor with current backends
+
+Goal:
+Separate domain ownership and persistence seams while still using the current JSON and in-memory backends.
+
+What changes:
+
+- introduce explicit `AgentSnapshotStore` and `AgentTimelineStore` seams
+- keep `ProjectRegistry` and `WorkspaceRegistry` as concrete domain seams rather than wrapping them in a generic repository abstraction
+- extract workspace reconciliation into a dedicated `WorkspaceReconciliationService`
+- collapse duplicate snapshot-writer paths so snapshot persistence ownership is explicit
+- isolate current in-memory timeline logic behind the timeline store interface
+- isolate refresh/load dependence on provider history rehydrate behind explicit seams so Phase 4 can remove it cleanly without another structural refactor
+
+Dependencies:
+
+- Phase 0 contract and message-shape cleanup should be settled enough that the extracted seams do not preserve `epoch`-era behavior by accident
+
+Tests required:
+
+- store contract tests for snapshot store and timeline store
+- registry contract tests for projects and workspaces
+- reconciliation tests using real temp directories and real filesystem mutations
+- refresh/load tests proving any remaining provider-history dependency is isolated behind explicit storage/session seams rather than scattered through the runtime
+
+Exit gate:
+The server can run unchanged behavior through explicit storage interfaces, duplicate snapshot-writer ownership is collapsed, and any remaining provider-history rehydrate dependency is isolated to a narrow compatibility path that Phase 4 can delete.
+
+Can happen in parallel:
+
+- snapshot-store extraction
+- reconciliation extraction
+- timeline-store interface extraction
+
+Must stay sequential:
+
+- duplicate snapshot-writer cleanup should land before DB-backed snapshot cutover
+- timeline store contract should settle before DB timeline work begins
+
+Suggested commit boundaries:
+
+- snapshot-store ownership cleanup
+- reconciliation-service extraction
+- timeline-store extraction with in-memory adapter
+
+### Phase 2: DB foundation
+
+Goal:
+Land the database runtime, schema, and migration tooling without yet making the DB the source of truth for every domain.
+
+What changes:
+
+- add Drizzle schema and migration workflow
+- add PGlite database bootstrap and lifecycle management
+- define tables for projects, workspaces, agent snapshots, and committed timeline history
+- choose indexes based on the first real query set, especially `agent_id + seq`
+- implement DB-backed adapters for the storage seams introduced in Phase 1
+
+Dependencies:
+
+- Phase 1 storage seams should exist before DB adapters become the main implementation path
+
+Tests required:
+
+- migration tests on fresh databases
+- migration tests on incremental schema upgrades
+- DB adapter tests against a real PGlite database
+- startup/shutdown tests for DB bootstrap in the daemon environment
+
+Exit gate:
+The repo can create, migrate, and query a real PGlite-backed Drizzle database in tests, and the new adapters satisfy the same contract tests as the current backends.
+
+Suggested commit boundaries:
+
+- Drizzle and PGlite foundation
+- schema plus migrations
+- DB adapters wired behind existing interfaces
+
+### Phase 3: Structured-record cutover and legacy JSON import
+
+Goal:
+Move projects, workspaces, and agent snapshot metadata onto the DB, with explicit import rules from existing Paseo homes.
+
+What changes:
+
+- make the DB-backed project/workspace stores authoritative
+- make the DB-backed agent snapshot store authoritative
+- import legacy `projects.json`, `workspaces.json`, and agent snapshot JSON into the DB
+- run workspace reconciliation against stored records and filesystem state
+- keep archive/unarchive and related metadata flows working through the new store ownership model
+
+Dependencies:
+
+- Phase 2 DB bootstrap, migrations, and DB-backed structured-record adapters must be stable first
+
+Tests required:
+
+- import tests from existing JSON files into empty DBs
+- idempotent re-import tests where the DB already contains matching rows
+- reconciliation tests covering deleted directories and archived-agent edge cases
+- agent list/fetch/workspace list session tests against DB-backed stores
+
+Exit gate:
+A daemon can start from a legacy Paseo home, import structured records into the DB, restart from the same home again without duplication or state drift, and serve project/workspace/agent metadata without depending on JSON files as the source of truth.
+
+Ordered rollout note:
+
+- first, project/workspace authority plus reconciliation and import harness
+- second, restart/idempotence verification on the structured-record path
+- third, agent snapshot metadata authority
+- structured records should cut over before timeline storage so the timeline phase can rely on stable DB-backed agent identity and metadata
+
+Suggested commit boundaries:
+
+- project/workspace DB cutover plus import harness and reconciliation
+- agent snapshot DB cutover and restart/idempotence tests
+
+### Phase 4: Timeline storage and catch-up cutover
+
+Goal:
+Move committed timeline history to storage-owned append-only rows and remove provider-history rehydrate from refresh/load.
+
+What changes:
+
+- make `AgentTimelineStore` authoritative for committed history
+- write one committed row per finalized history item
+- stop storing raw chunk rows as committed history
+- keep provisional live updates in memory/subscription scope only
+- make fetch/catch-up query committed rows by `agent_id + seq`
+- remove provider-history rehydrate from normal refresh/load flows
+- remove retention-window timeline trimming and epoch-reset behavior for committed history
+
+Dependencies:
+
+- Phase 0 contract cleanup
+- Phase 2 DB foundation
+- Phase 3 structured-record cutover, so timeline rows attach to stable DB-backed agent metadata and identity
+
+Tests required:
+
+- timeline store contract tests against real PGlite
+- live-to-commit tests for assistant, tool, and reasoning-live-only behavior
+- reconnect tests covering committed catch-up plus provisional seed ordering
+- migration/cutover tests proving refresh/load do not import provider history
+- scenario tests for:
+- live stream while connected
+- disconnect after committed seq `N`, reconnect, `fetch-after-seq(N)`, then resume live without gaps or duplicates
+- daemon restart, then fetch committed history without provider rehydrate
+- `attach`/`logs` against an agent with committed stored history but no active provider session
+
+Exit gate:
+Committed timeline history survives daemon restart, reconnect from a known committed seq yields ordered history with no gaps or duplicates across catch-up plus live resume, including the provisional-seed case, and refresh/load no longer depend on provider history replay.
+
+Internal sub-gates:
+
+- write-path parity is established before the DB-backed timeline writer becomes authoritative
+- `fetch-after-seq` parity is established before legacy committed-history reads are removed
+- reconnect no-gap/no-duplicate behavior is proven before timeline cutover is considered complete
+- refresh/load de-rehydrate removal lands only after committed-history write and read authority are stable
+
+Can happen in parallel:
+
+- timeline write path
+- fetch/catch-up query path
+- CLI/app verification against storage-backed committed history behavior
+
+Must stay sequential:
+
+- this phase depends on Phase 0 contract cleanup and Phase 2 DB foundation
+- it should land after Phase 3 so agent and workspace identity are already DB-backed
+
+Suggested commit boundaries:
+
+- gated committed timeline store plus write/read parity work, not yet authoritative until matching read-path coverage exists
+- authoritative fetch/catch-up cutover together with reconnect scenario coverage
+- refresh/load de-rehydrate cleanup and related tests
+
+### Phase 5: Cleanup and removal
+
+Goal:
+Delete legacy paths once DB-backed storage and the simplified contract are proven.
+
+What changes:
+
+- remove legacy JSON source-of-truth paths for projects, workspaces, and agent snapshots
+- remove in-memory committed timeline ownership and retention trimming
+- remove leftover compatibility code and dead reducers from the pre-Phase-0 timeline model
+- remove provider-history hydration paths that are no longer part of refresh/load
+- update architecture and developer docs to reflect the new ownership model
+
+Dependencies:
+
+- Phase 3 and Phase 4 must both have passed their exit gates
+
+Tests required:
+
+- full server typecheck and existing relevant test suites
+- targeted regression tests for deleted legacy branches
+- migration tests proving old homes still import correctly into the new model
+
+Exit gate:
+There is one durable storage path for structured records and committed timeline history, normal runtime no longer writes legacy JSON or in-memory committed-history branches, and no runtime behavior depends on the removed JSON/in-memory history model.
+
+Suggested commit boundaries:
+
+- legacy path removal
+- doc updates and final contract cleanup
+
+## Legacy data and import constraints
+
+The migration story is intentionally narrower than a full historical backfill.
+
+What can be imported from existing Paseo homes:
+
+- projects from `projects/projects.json`
+- workspaces from `projects/workspaces.json`
+- agent snapshot metadata from agent JSON files
+
+What cannot be broadly backfilled:
+
+- committed timeline history that never existed in Paseo storage
+- raw provider history that would need to be rehydrated on refresh/load
+- provisional live state from prior daemon lifetimes
+
+That means the honest timeline migration story is:
+
+- existing committed history only exists for whatever Paseo has already written under the new timeline store
+- after cutover, timeline history is durable and append-only
+- before cutover, old homes do not gain full historical timelines unless a separate import source is defined later
+
+This is a feature, not a gap. It keeps the new contract storage-owned instead of reintroducing provider-specific replay semantics.
+
+## Orchestrator audit plan
+
+Every implementation slice requires an independent audit pass before it is accepted. Audit agents verify; they do not edit files. A phase is not complete until its audit gate passes.
+
+Audit prompts should be checklist-based and evidence-driven. The point of these passes is to catch regressions, hidden behavior changes, missing tests, two-authority drift, and unnecessary complexity before the next phase begins.
+
+### Phase 0 audit
+
+The audit pass must verify:
+
+- the public contract actually removed `epoch`, `reset`, and projection-heavy response baggage where intended
+- `timeline` with `seq` vs without `seq` behaves as specified
+- the explicit `seq = 120 -> 121` reconnect scenario is covered by tests
+- older-history pagination still works under the committed-history contract
+- app reducer and session/WebSocket behavior match the agreed contract
+
+### Phase 1 audit
+
+The audit pass must verify:
+
+- no functional behavior changed beyond the intended seam refactor
+- duplicate snapshot-writer ownership is actually collapsed
+- reconciliation ownership is actually extracted from `Session`
+- provider-history dependency is isolated and not still scattered through runtime code
+- seam contract tests exist and pass
+
+### Phase 2 audit
+
+The audit pass must verify:
+
+- fresh migrations succeed
+- incremental migrations succeed
+- DB adapters pass the same contract tests as current backends
+- bootstrap and shutdown are stable
+- no DB path is prematurely authoritative unless explicitly intended
+
+### Phase 3 audit
+
+The audit pass must verify:
+
+- import from a legacy Paseo home works
+- restarting from the same legacy home does not duplicate or drift structured records
+- project, workspace, and agent metadata behavior matches prior behavior
+- reconciliation still surfaces stale or missing workspaces correctly
+- archive, unarchive, list, and fetch flows still work
+
+### Phase 4 audit
+
+The audit pass must verify:
+
+- committed history survives daemon restart
+- `fetch-after-seq` and `fetch-before-seq` behave correctly
+- no raw chunk rows are persisted
+- reconnect satisfies the no-gap/no-duplicate invariant
+- the `120 -> 121` reconnect scenario is explicitly verified
+- unloaded or restarted agent history reads work without provider rehydrate
+- CLI and app history behaviors such as `logs`, `attach`, and timeline fetch still work against committed stored history
+
+### Phase 5 audit
+
+The audit pass must verify:
+
+- normal runtime no longer writes legacy JSON or in-memory committed-history branches
+- dead compatibility branches are actually gone
+- relevant test suites and typecheck pass
+- legacy-home import still works under the final model
+
+## Open questions and risks
+
+Open product or implementation questions:
+
+- should subscribe-time provisional seeding always happen when a turn is active, or only when the client asks for streaming state
+- do we want a durable system/error timeline row for failed or canceled turns, or should those remain transport-only
+- do any providers require an extra adapter constraint to uphold the single-provisional-stream invariant
+
+Main risks and mitigations:
+
+- risk: the plan quietly recreates projection complexity inside the DB schema
+  mitigation: store canonical committed rows only, and keep raw/provisional data out of durable history
+
+- risk: refresh/load still leaks provider-history import back into the committed-history path
+  mitigation: make de-rehydrate behavior a named Phase 4 gate with dedicated tests
+
+- risk: legacy import over-promises timeline backfill
+  mitigation: keep timeline migration constraints explicit and separate from structured-record import
+
+- risk: the storage refactor turns into a large abstraction exercise
+  mitigation: keep the seam list concrete and domain-shaped; avoid generic repository frameworks
+
+- risk: sequencing gets inverted and DB work begins before the protocol and ownership model settle
+  mitigation: keep Phase 0 and Phase 1 as hard prerequisites for DB timeline cutover
@@ -0,0 +1,170 @@
+# Agent Event Stream Redesign
+
+Status: **Implemented** (2026-03-24)
+
+## Problem
+
+The Claude provider had three event paths delivering the same events to the agent-manager:
+
+1. **Foreground stream** (`stream()` → `activeForegroundTurn.queue`)
+2. **Live event pump** (`streamLiveEvents()` → `liveEventQueue`) fed by the query pump
+3. **JSONL history poller** (`startLiveHistoryPolling()` → `routeSdkMessageFromPump()`)
+
+Routing between paths was timing-based (`Boolean(activeForegroundTurn)`, `pendingRun`). This caused:
+
+- **Duplicate user messages**: trailing SDK events routed to the live queue after `activeForegroundTurn` cleared
+- **Stuck running state**: stale `turn_started` from the live path flipped lifecycle back to `running` after finalize set it to terminal
+- **Fragile dedup**: `shouldSuppressLiveUserMessageEcho` checked `pendingRun` (already null) and `messageId` (Claude assigns its own UUID)
+
+Codex and OpenCode were stable because they had ONE event path with no routing decision.
+
+## Design
+
+### Core principle
+
+One event source per provider session. Identity-based turn ownership, not timing-based routing.
+
+### Provider contract (`AgentSession`)
+
+```typescript
+interface AgentSession {
+  readonly provider: AgentProvider;
+  readonly id: string | null;
+  readonly capabilities: AgentCapabilityFlags;
+
+  // Turn lifecycle
+  startTurn(prompt: AgentPromptInput, options?: AgentRunOptions): Promise<{ turnId: string }>;
+  interrupt(): Promise<void>;
+
+  // Event delivery (push-based)
+  subscribe(callback: (event: AgentStreamEvent) => void): () => void;
+
+  // History (hydration only — never live dispatch)
+  streamHistory(): AsyncGenerator<AgentStreamEvent>;
+
+  // Run (uses startTurn + subscribe internally)
+  run(prompt: AgentPromptInput, options?: AgentRunOptions): Promise<AgentRunResult>;
+
+  // Session metadata (unchanged)
+  getRuntimeInfo(): Promise<AgentRuntimeInfo>;
+  getAvailableModes(): Promise<AgentMode[]>;
+  getCurrentMode(): Promise<string | null>;
+  setMode(modeId: string): Promise<void>;
+  getPendingPermissions(): AgentPermissionRequest[];
+  respondToPermission(requestId: string, response: AgentPermissionResponse): Promise<void>;
+  describePersistence(): AgentPersistenceHandle | null;
+  close(): Promise<void>;
+  listCommands?(): Promise<AgentSlashCommand[]>;
+  setModel?(modelId: string | null): Promise<void>;
+  setThinkingOption?(thinkingOptionId: string | null): Promise<void>;
+}
+```
+
+### Method contracts
+
+#### `startTurn(prompt, options?): Promise<{ turnId: string }>`
+
+Initiates a foreground turn. The provider validates readiness, generates a unique `turnId`, submits the prompt to the runtime, and resolves once accepted. Resolving means the prompt was accepted — not that the turn has started processing.
+
+Rejects if: session not connected, foreground turn already active, runtime rejects prompt.
+
+#### `subscribe(callback): () => void`
+
+Registers a callback that receives ALL provider events — foreground and autonomous — in provider order. Returns an unsubscribe function. Events carry `turnId` when they belong to a turn.
+
+#### `streamHistory(): AsyncGenerator<AgentStreamEvent>`
+
+Yields persisted timeline items from prior sessions. Hydration only. Does NOT yield live events.
+
+#### `interrupt(): Promise<void>`
+
+Cancels the active foreground turn. The resulting `turn_canceled` event arrives via `subscribe()`.
+
+### Provider-side guarantees
+
+1. **Per-session ordering**: callbacks invoked in provider event order
+2. **No concurrent callback execution**: serialized delivery per session
+3. **Subscribe-before-start safety**: manager subscribes at session creation, before any `startTurn()` call — no events missed
+4. **Callback error isolation**: subscriber throws → provider logs and continues
+5. **Deterministic cleanup**: `close()` stops all callbacks; `unsubscribe()` stops that specific callback
+
+### Event tagging
+
+All turn-scoped events carry `turnId: string`. Providers stamp turnId in `notifySubscribers()` from the active turn state (`activeForegroundTurnId` or `autonomousTurn.id`). The manager derives turn kind (foreground vs autonomous) by comparing against its own `activeForegroundTurnId`.
+
+### User message dedup
+
+Claude SDK assigns its own UUID to user messages (does not preserve ours). The provider deduplicates user_message echoes by text content against the most recent foreground prompt.
+
+## Manager
+
+### Single subscription per session
+
+When a session is loaded, the manager subscribes once via `session.subscribe()`. This is the only live input path. Events flow through a single dispatcher that handles lifecycle projection, foreground turn waiters, and UI updates.
+
+### Lifecycle projection from turn identity
+
+- After `startTurn()` resolves: foreground turn is active
+- On `turn_started` for active foreground turnId: lifecycle = `running`
+- On terminal for active foreground turnId: lifecycle = `idle` or `error`, clear foreground turn
+- On autonomous `turn_started`: lifecycle = `running`
+- On autonomous terminal: lifecycle = `idle` or `error`
+
+### `streamAgent()` as filtered view
+
+```typescript
+async *streamAgent(agentId, prompt, options) {
+  const { turnId } = await session.startTurn(prompt, options);
+  agent.activeForegroundTurnId = turnId;
+
+  // Foreground turn waiter yields events matching this turnId
+  // Ends when terminal event for turnId arrives
+}
+```
+
+### State model
+
+| Concept | Implementation |
+|---------|---------------|
+| Foreground turn tracking | `activeForegroundTurnId: string \| null` |
+| Lifecycle projection | From turn events via turnId matching |
+| Cancellation | `session.interrupt()` + await waiter settlement |
+
+## What was deleted
+
+- `stream()` from `AgentSession` interface and all providers
+- `Pushable<T>` async queue from all providers
+- `streamLiveEvents()` capability
+- `activeForegroundTurn` + foreground queue in Claude provider
+- `liveEventQueue` in Claude provider
+- `routeSdkMessageFromPump()` timing-based routing (simplified to direct dispatch)
+- `startLiveEventPump()` in manager
+- `liveEventBacklog` + `flushLiveEventBacklog()` in manager
+- `shouldSuppressLiveUserMessageEcho()` in manager
+- `startLiveHistoryPolling()` for live dispatch
+- `snapHistoryOffsetToEnd()`
+- `pendingRun` as iterator reference
+
+## Integration tests
+
+All tests run against real Claude sessions with credentials from `.env.test`. No mocks.
+
+File: `packages/server/src/server/agent/providers/__tests__/claude-agent.event-stream.integration.test.ts`
+
+| Test | What it verifies |
+|------|-----------------|
+| Basic foreground turn | startTurn → events via subscribe → terminal with matching turnId |
+| No duplicate user_messages | Exactly ONE user_message per prompt, even after terminal |
+| Lifecycle doesn't get stuck | No stale turn_started after terminal for same turnId |
+| Autonomous run | sleep 5 in bg → idle → autonomous wake → idle (distinct turnIds) |
+| Interruption | Start long task → interrupt → turn_canceled arrives |
+| Sequential turns | Two turns produce distinct turnIds, no cross-contamination |
+| Fast-fail | Quick error produces clean terminal, no stale events |
+| User message dedup | Exactly one user_message with matching text in event log |
+
+### Invariants (asserted on every test)
+
+1. For each foreground turnId, exactly ONE `user_message` event
+2. Every `turn_started` has exactly one matching terminal
+3. After terminal for a foreground turnId, no later event with that turnId gets projected as autonomous
+4. Autonomous turns between foreground turns are visible with distinct turnIds
@@ -1,27 +0,0 @@
-{
-  "nodes": {
-    "nixpkgs": {
-      "locked": {
-        "lastModified": 1772963539,
-        "narHash": "sha256-9jVDGZnvCckTGdYT53d/EfznygLskyLQXYwJLKMPsZs=",
-        "owner": "NixOS",
-        "repo": "nixpkgs",
-        "rev": "9dcb002ca1690658be4a04645215baea8b95f31d",
-        "type": "github"
-      },
-      "original": {
-        "owner": "NixOS",
-        "ref": "nixos-unstable",
-        "repo": "nixpkgs",
-        "type": "github"
-      }
-    },
-    "root": {
-      "inputs": {
-        "nixpkgs": "nixpkgs"
-      }
-    }
-  },
-  "root": "root",
-  "version": 7
-}
@@ -1,59 +0,0 @@
-{
-  description = "Paseo - self-hosted daemon for AI coding agents";
-
-  inputs = {
-    nixpkgs.url = "github:NixOS/nixpkgs/nixos-unstable";
-  };
-
-  outputs =
-    {
-      self,
-      nixpkgs,
-    }:
-    let
-      supportedSystems = [
-        "x86_64-linux"
-        "aarch64-linux"
-        "x86_64-darwin"
-        "aarch64-darwin"
-      ];
-      forAllSystems = nixpkgs.lib.genAttrs supportedSystems;
-      pkgsFor = system: import nixpkgs { inherit system; };
-    in
-    {
-      packages = forAllSystems (
-        system:
-        let
-          pkgs = pkgsFor system;
-          paseo = pkgs.callPackage ./nix/package.nix { };
-        in
-        {
-          default = paseo;
-          paseo = paseo;
-        }
-      );
-
-      nixosModules.default = self.nixosModules.paseo;
-      nixosModules.paseo =
-        { pkgs, lib, ... }:
-        {
-          imports = [ ./nix/module.nix ];
-          services.paseo.package = lib.mkDefault self.packages.${pkgs.stdenv.hostPlatform.system}.default;
-        };
-
-      devShells = forAllSystems (
-        system:
-        let
-          pkgs = pkgsFor system;
-        in
-        {
-          default = pkgs.mkShell {
-            packages = [
-              pkgs.nodejs_22
-              pkgs.python3
-            ];
-          };
-        }
-      );
-    };
-}
@@ -1,172 +0,0 @@
-{
-  config,
-  lib,
-  pkgs,
-  ...
-}:
-
-let
-  cfg = config.services.paseo;
-in
-{
-  options.services.paseo = {
-    enable = lib.mkEnableOption "Paseo, a self-hosted daemon for AI coding agents";
-
-    package = lib.mkPackageOption pkgs "paseo" { };
-
-    user = lib.mkOption {
-      type = lib.types.str;
-      default = "paseo";
-      description = "User account under which Paseo runs.";
-    };
-
-    group = lib.mkOption {
-      type = lib.types.str;
-      default = "paseo";
-      description = "Group under which Paseo runs.";
-    };
-
-    dataDir = lib.mkOption {
-      type = lib.types.str;
-      default =
-        if cfg.user == "paseo"
-        then "/var/lib/paseo"
-        else "/home/${cfg.user}/.paseo";
-      defaultText = lib.literalExpression ''
-        if cfg.user == "paseo"
-        then "/var/lib/paseo"
-        else "/home/''${cfg.user}/.paseo"
-      '';
-      description = "Directory for Paseo state (PASEO_HOME). Stores agent data, config, and logs.";
-    };
-
-    port = lib.mkOption {
-      type = lib.types.port;
-      default = 6767;
-      description = "Port for the Paseo daemon to listen on.";
-    };
-
-    listenAddress = lib.mkOption {
-      type = lib.types.str;
-      default = "127.0.0.1";
-      description = "Address for the Paseo daemon to bind to.";
-    };
-
-    openFirewall = lib.mkOption {
-      type = lib.types.bool;
-      default = false;
-      description = "Whether to open the firewall for the Paseo daemon port.";
-    };
-
-    allowedHosts = lib.mkOption {
-      type = lib.types.either (lib.types.enum [ true ]) (lib.types.listOf lib.types.str);
-      default = [ ];
-      example = [ ".example.com" "myhost.local" ];
-      description = ''
-        Hosts allowed to connect to the Paseo daemon (DNS rebinding protection).
-        Localhost and IP addresses are always allowed by default.
-
-        Use a leading dot to match a domain and all its subdomains
-        (e.g. `".example.com"` matches `example.com` and `foo.example.com`).
-
-        Set to `true` to allow any host (not recommended).
-      '';
-    };
-
-    relay = {
-      enable = lib.mkOption {
-        type = lib.types.bool;
-        default = true;
-        description = "Whether to enable the relay connection for remote access via app.paseo.sh.";
-      };
-    };
-
-    inheritUserEnvironment = lib.mkOption {
-      type = lib.types.bool;
-      default = cfg.user != "paseo";
-      defaultText = lib.literalExpression ''cfg.user != "paseo"'';
-      description = ''
-        Whether to include the user's profile PATH in the service environment.
-
-        When Paseo runs as a real user (not the default system user), AI agents
-        need access to the user's tools (git, ssh, etc.). This adds the user's
-        NixOS profile and system paths so agents can use them without manually
-        setting PATH.
-
-        Enabled by default when `user` is set to a non-default value.
-      '';
-    };
-
-    environment = lib.mkOption {
-      type = lib.types.attrsOf lib.types.str;
-      default = { };
-      example = lib.literalExpression ''
-        {
-          PASEO_RELAY_ENDPOINT = "relay.paseo.sh:443";
-        }
-      '';
-      description = "Extra environment variables for the Paseo daemon.";
-    };
-  };
-
-  config = lib.mkIf cfg.enable {
-    users.users.${cfg.user} = lib.mkIf (cfg.user == "paseo") {
-      isSystemUser = true;
-      group = cfg.group;
-      home = cfg.dataDir;
-    };
-
-    users.groups.${cfg.group} = lib.mkIf (cfg.group == "paseo") { };
-
-    systemd.tmpfiles.rules = [
-      "d ${cfg.dataDir} 0700 ${cfg.user} ${cfg.group} - -"
-    ];
-
-    systemd.services.paseo = {
-      description = "Paseo - self-hosted daemon for AI coding agents";
-      after = [ "network.target" ];
-      wantedBy = [ "multi-user.target" ];
-
-      environment = {
-        NODE_ENV = "production";
-        PASEO_HOME = cfg.dataDir;
-        PASEO_LISTEN = "${cfg.listenAddress}:${toString cfg.port}";
-      } // lib.optionalAttrs cfg.inheritUserEnvironment {
-        # mkForce overrides the default PATH from NixOS's systemd module (which
-        # only includes store paths for coreutils/grep/sed/systemd). Our PATH
-        # includes /run/current-system/sw/bin which is a superset of those.
-        PATH = lib.mkForce (lib.concatStringsSep ":" [
-          "/etc/profiles/per-user/${cfg.user}/bin"
-          "/run/current-system/sw/bin"
-          "/run/wrappers/bin"
-          "/nix/var/nix/profiles/default/bin"
-        ]);
-      } // lib.optionalAttrs (cfg.allowedHosts == true) {
-        PASEO_ALLOWED_HOSTS = "true";
-      } // lib.optionalAttrs (lib.isList cfg.allowedHosts && cfg.allowedHosts != [ ]) {
-        PASEO_ALLOWED_HOSTS = lib.concatStringsSep "," cfg.allowedHosts;
-      } // cfg.environment;
-
-      serviceConfig = {
-        Type = "simple";
-        User = cfg.user;
-        Group = cfg.group;
-
-        ExecStart =
-          "${cfg.package}/bin/paseo-server"
-          + lib.optionalString (!cfg.relay.enable) " --no-relay";
-
-        Restart = "on-failure";
-        RestartSec = 5;
-
-        # Graceful shutdown (server handles SIGTERM with a 10s timeout)
-        KillSignal = "SIGTERM";
-        TimeoutStopSec = 15;
-      };
-    };
-
-    environment.systemPackages = [ cfg.package ];
-
-    networking.firewall.allowedTCPPorts = lib.mkIf cfg.openFirewall [ cfg.port ];
-  };
-}
@@ -1,144 +0,0 @@
-{
-  lib,
-  stdenv,
-  buildNpmPackage,
-  nodejs_22,
-  python3,
-  makeWrapper,
-  # node-pty needs libuv headers on Linux
-  libuv,
-}:
-
-buildNpmPackage rec {
-  pname = "paseo";
-  version = (builtins.fromJSON (builtins.readFile ../package.json)).version;
-
-  src = lib.cleanSourceWith {
-    src = ./..;
-    filter = path: type:
-      let
-        baseName = builtins.baseNameOf path;
-        relPath = lib.removePrefix (toString ./..) path;
-      in
-      # Exclude non-daemon workspace contents (keep package.json for workspace resolution)
-      !(lib.hasPrefix "/packages/app/src" relPath)
-      && !(lib.hasPrefix "/packages/app/assets" relPath)
-      && !(lib.hasPrefix "/packages/app/android" relPath)
-      && !(lib.hasPrefix "/packages/app/ios" relPath)
-      && !(lib.hasPrefix "/packages/website/src" relPath)
-      && !(lib.hasPrefix "/packages/website/public" relPath)
-      && !(lib.hasPrefix "/packages/desktop/src" relPath)
-      && !(lib.hasPrefix "/packages/desktop/src-tauri" relPath)
-      # Exclude test fixtures and debug files
-      && !(lib.hasSuffix ".test.ts" baseName)
-      && !(lib.hasSuffix ".e2e.test.ts" baseName)
-      && baseName != "node_modules"
-      && baseName != ".git"
-      && baseName != ".paseo"
-      && baseName != ".DS_Store";
-  };
-
-  nodejs = nodejs_22;
-
-  # To update: run `nix build` with lib.fakeHash, copy the `got:` hash.
-  # CI auto-updates this when package-lock.json changes (see .github/workflows/).
-  npmDepsHash = "sha256-jBl1E7cwEf5XKXFQip/ZlEa/zNQoz0Hq5t0hqjp8Qe4=";
-
-  # Prevent onnxruntime-node's install script from running during automatic
-  # npm rebuild (it tries to download from api.nuget.org, which fails in the sandbox).
-  # We manually rebuild only node-pty in buildPhase.
-  npmRebuildFlags = [ "--ignore-scripts" ];
-
-  nativeBuildInputs = [
-    python3 # for node-gyp (node-pty compilation)
-    makeWrapper
-  ];
-
-  buildInputs = lib.optionals stdenv.hostPlatform.isLinux [
-    libuv
-  ];
-
-  # Don't use the default npm build hook — we need a custom build sequence
-  dontNpmBuild = true;
-
-  buildPhase = ''
-    runHook preBuild
-
-    # Rebuild only node-pty (native addon for terminal emulation).
-    # Speech-related native modules (sherpa-onnx, onnxruntime-node) are
-    # intentionally left unbuilt — they're lazily loaded and gracefully
-    # degrade when unavailable.
-    npm rebuild node-pty
-
-    # Build all daemon packages in dependency order (defined in package.json)
-    npm run build:daemon
-
-    runHook postBuild
-  '';
-
-  installPhase = ''
-    runHook preInstall
-
-    mkdir -p $out/lib/paseo
-
-    # Copy root package metadata
-    cp package.json $out/lib/paseo/
-
-    # Copy node_modules (preserving workspace symlinks)
-    cp -a node_modules $out/lib/paseo/
-
-    # Auto-detect which @getpaseo/* packages were built by build:daemon
-    # (they'll have a dist/ directory). Copy those and remove the rest.
-    for link in $out/lib/paseo/node_modules/@getpaseo/*; do
-      name=$(basename "$link")
-      if [ -d "packages/$name/dist" ]; then
-        mkdir -p "$out/lib/paseo/packages/$name"
-        cp "packages/$name/package.json" "$out/lib/paseo/packages/$name/"
-        cp -a "packages/$name/dist" "$out/lib/paseo/packages/$name/"
-        if [ -d "packages/$name/node_modules" ]; then
-          cp -a "packages/$name/node_modules" "$out/lib/paseo/packages/$name/"
-        fi
-      else
-        rm -f "$link"
-      fi
-    done
-
-    # Copy CLI bin entry
-    mkdir -p $out/lib/paseo/packages/cli/bin
-    cp packages/cli/bin/paseo $out/lib/paseo/packages/cli/bin/
-
-    # Copy extra server files referenced at runtime
-    for f in agent-prompt.md .env.example; do
-      if [ -f packages/server/$f ]; then
-        cp packages/server/$f $out/lib/paseo/packages/server/
-      fi
-    done
-
-    # Copy server scripts (daemon-runner, supervisor) needed by CLI
-    if [ -d packages/server/dist/scripts ]; then
-      mkdir -p $out/lib/paseo/packages/server/dist/scripts
-      cp -a packages/server/dist/scripts/* $out/lib/paseo/packages/server/dist/scripts/
-    fi
-
-    # Create wrapper for the server entry point (for systemd / direct use)
-    mkdir -p $out/bin
-    makeWrapper ${nodejs}/bin/node $out/bin/paseo-server \
-      --add-flags "$out/lib/paseo/packages/server/dist/server/server/index.js" \
-      --set NODE_ENV production
-
-    # Create wrapper for the CLI
-    makeWrapper ${nodejs}/bin/node $out/bin/paseo \
-      --add-flags "$out/lib/paseo/packages/cli/dist/index.js" \
-      --set NODE_PATH "$out/lib/paseo/node_modules"
-
-    runHook postInstall
-  '';
-
-  meta = {
-    description = "Self-hosted daemon for Claude Code, Codex, and OpenCode";
-    homepage = "https://github.com/getpaseo/paseo";
-    license = lib.licenses.agpl3Plus;
-    mainProgram = "paseo";
-    platforms = lib.platforms.linux ++ lib.platforms.darwin;
-  };
-}
@@ -1,6 +1,6 @@
 {
  "name": "paseo",
-  "version": "0.1.37",
+  "version": "0.1.33",
  "private": true,
  "workspaces": [
    "packages/expo-two-way-audio",
@@ -37,6 +37,7 @@
    "web": "npm run web --workspace=@getpaseo/app",
    "dev:desktop": "npm run dev --workspace=@getpaseo/desktop",
    "build:desktop": "npm run version:sync-internal && npm run build:web --workspace=@getpaseo/app && npm run build --workspace=@getpaseo/desktop",
+    "db:query": "npm run db:query --workspace=@getpaseo/server --",
    "cli": "npx tsx packages/cli/src/index.js",
    "version": "npm run version:sync-internal && npm run release:prepare && git add -A",
    "version:sync-internal": "node scripts/sync-workspace-versions.mjs",
@@ -49,13 +50,13 @@
    "release:publish": "npm publish --workspace=@getpaseo/highlight --access public && npm publish --workspace=@getpaseo/relay --access public && npm publish --workspace=@getpaseo/server --access public && npm publish --workspace=@getpaseo/cli --access public",
    "release:push": "node scripts/push-current-release-tag.mjs",
    "draft-release:push": "node scripts/push-current-release-tag.mjs --draft-release",
-    "draft-release:patch": "npm run release:check && npm run version:all:patch && npm run draft-release:push",
-    "draft-release:minor": "npm run release:check && npm run version:all:minor && npm run draft-release:push",
-    "draft-release:major": "npm run release:check && npm run version:all:major && npm run draft-release:push",
+    "draft-release:patch": "npm run version:all:patch && npm run release:check && npm run draft-release:push",
+    "draft-release:minor": "npm run version:all:minor && npm run release:check && npm run draft-release:push",
+    "draft-release:major": "npm run version:all:major && npm run release:check && npm run draft-release:push",
    "release:finalize": "node scripts/finalize-current-release.mjs",
-    "release:patch": "npm run release:check && npm run version:all:patch && npm run release:publish && npm run release:push",
-    "release:minor": "npm run release:check && npm run version:all:minor && npm run release:publish && npm run release:push",
-    "release:major": "npm run release:check && npm run version:all:major && npm run release:publish && npm run release:push"
+    "release:patch": "npm run version:all:patch && npm run release:check && npm run release:publish && npm run release:push",
+    "release:minor": "npm run version:all:minor && npm run release:check && npm run release:publish && npm run release:push",
+    "release:major": "npm run version:all:major && npm run release:check && npm run release:publish && npm run release:push"
  },
  "devDependencies": {
    "@biomejs/biome": "^2.4.8",
@@ -68,7 +69,6 @@
    "typescript": "^5.9.3"
  },
  "description": "Paseo: voice-controlled development environment with OpenAI Realtime API",
-  "homepage": "https://paseo.sh",
  "keywords": [
    "openai",
    "realtime",
@@ -77,14 +77,7 @@
    "development",
    "mcp"
  ],
-  "author": {
-    "name": "Mohamed Boudra",
-    "email": "hello@moboudra.com"
-  },
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/getpaseo/paseo.git"
-  },
+  "author": "moboudra",
  "license": "AGPL-3.0-or-later",
  "overrides": {
    "lightningcss": "1.30.1",
@@ -448,15 +448,12 @@ export default async function globalSetup() {
        PASEO_LISTEN: `0.0.0.0:${port}`,
        PASEO_RELAY_ENDPOINT: `127.0.0.1:${relayPort}`,
        PASEO_CORS_ORIGINS: `http://localhost:${metroPort}`,
-        PASEO_DICTATION_ENABLED: openAiUsable ? "1" : "0",
-        PASEO_VOICE_MODE_ENABLED: openAiUsable ? "1" : "0",
-        ...(openAiUsable
-          ? {
-              PASEO_DICTATION_STT_PROVIDER: "openai",
-              PASEO_VOICE_STT_PROVIDER: "openai",
-              PASEO_VOICE_TTS_PROVIDER: "openai",
-            }
-          : {}),
+        // Use OpenAI speech providers in e2e to avoid local model bootstrapping delays.
+        PASEO_DICTATION_ENABLED: "1",
+        PASEO_VOICE_MODE_ENABLED: "1",
+        PASEO_DICTATION_STT_PROVIDER: dictationProvider,
+        PASEO_VOICE_STT_PROVIDER: "openai",
+        PASEO_VOICE_TTS_PROVIDER: "openai",
        ...(localModelsDir ? { PASEO_LOCAL_MODELS_DIR: localModelsDir } : {}),
        NODE_ENV: "development",
      },
@@ -1,228 +0,0 @@
-import type { Page } from "@playwright/test";
-import path from "node:path";
-import { pathToFileURL } from "node:url";
-import { randomUUID } from "node:crypto";
-import { buildHostWorkspaceRoute } from "../../src/utils/host-routes";
-
-export type TerminalPerfDaemonClient = {
-  connect(): Promise<void>;
-  close(): Promise<void>;
-  createTerminal(
-    cwd: string,
-    name?: string,
-  ): Promise<{
-    terminal: { id: string; name: string; cwd: string } | null;
-    error: string | null;
-  }>;
-  subscribeTerminal(
-    terminalId: string,
-  ): Promise<{ terminalId: string; slot: number; error: null } | { error: string }>;
-  sendTerminalInput(
-    terminalId: string,
-    message: { type: "input"; data: string } | { type: "resize"; rows: number; cols: number },
-  ): void;
-  onTerminalStreamEvent(
-    handler: (event: { terminalId: string; type: string; data?: Uint8Array }) => void,
-  ): () => void;
-  killTerminal(terminalId: string): Promise<{ error: string | null }>;
-};
-
-function getDaemonWsUrl(): string {
-  const daemonPort = process.env.E2E_DAEMON_PORT;
-  if (!daemonPort) {
-    throw new Error("E2E_DAEMON_PORT is not set.");
-  }
-  return `ws://127.0.0.1:${daemonPort}/ws`;
-}
-
-function getServerId(): string {
-  const serverId = process.env.E2E_SERVER_ID;
-  if (!serverId) {
-    throw new Error("E2E_SERVER_ID is not set.");
-  }
-  return serverId;
-}
-
-async function loadDaemonClientConstructor(): Promise<
-  new (config: { url: string; clientId: string; clientType: "cli" }) => TerminalPerfDaemonClient
-> {
-  const repoRoot = path.resolve(process.cwd(), "../..");
-  const moduleUrl = pathToFileURL(
-    path.join(repoRoot, "packages/server/dist/server/server/exports.js"),
-  ).href;
-  const mod = (await import(moduleUrl)) as {
-    DaemonClient: new (config: {
-      url: string;
-      clientId: string;
-      clientType: "cli";
-    }) => TerminalPerfDaemonClient;
-  };
-  return mod.DaemonClient;
-}
-
-export async function connectTerminalClient(): Promise<TerminalPerfDaemonClient> {
-  const DaemonClient = await loadDaemonClientConstructor();
-  const client = new DaemonClient({
-    url: getDaemonWsUrl(),
-    clientId: `terminal-perf-${randomUUID()}`,
-    clientType: "cli",
-  });
-  await client.connect();
-  return client;
-}
-
-export function buildTerminalWorkspaceUrl(cwd: string, terminalId: string): string {
-  const serverId = getServerId();
-  const route = buildHostWorkspaceRoute(serverId, cwd);
-  return `${route}?open=${encodeURIComponent(`terminal:${terminalId}`)}`;
-}
-
-export async function getTerminalBufferText(page: Page): Promise<string> {
-  return page.evaluate(() => {
-    const term = (window as any).__paseoTerminal;
-    if (!term) {
-      return "";
-    }
-    const buf = term.buffer.active;
-    const lines: string[] = [];
-    for (let i = 0; i < buf.length; i++) {
-      const line = buf.getLine(i);
-      if (line) {
-        lines.push(line.translateToString(true));
-      }
-    }
-    return lines.join("\n");
-  });
-}
-
-export async function waitForTerminalContent(
-  page: Page,
-  predicate: (text: string) => boolean,
-  timeout: number,
-): Promise<void> {
-  const deadline = Date.now() + timeout;
-  while (Date.now() < deadline) {
-    const text = await getTerminalBufferText(page);
-    if (predicate(text)) {
-      return;
-    }
-    await page.waitForTimeout(50);
-  }
-  throw new Error(`Terminal content did not match predicate within ${timeout}ms`);
-}
-
-export async function navigateToTerminal(
-  page: Page,
-  input: { cwd: string; terminalId: string },
-): Promise<void> {
-  // Boot the app at the workspace route directly.
-  // The fixtures.ts beforeEach addInitScript seeds localStorage on every navigation,
-  // so the daemon registry is already configured when the app starts.
-  const workspaceRoute = buildHostWorkspaceRoute(getServerId(), input.cwd);
-  await page.goto(workspaceRoute);
-
-  // Wait for daemon connection (sidebar shows host label)
-  await page.getByText("localhost", { exact: true }).first().waitFor({ state: "visible", timeout: 15_000 });
-
-  // The workspace should now query listTerminals and discover our terminal.
-  // Click the terminal tab if it auto-appeared, or wait for it.
-  const terminalSurface = page.locator('[data-testid="terminal-surface"]');
-  const surfaceVisible = await terminalSurface.isVisible().catch(() => false);
-
-  if (!surfaceVisible) {
-    // Terminal tab might not be focused — look for it in the tab row and click it
-    const terminalTab = page.locator(`[data-testid="workspace-tab-terminal:${input.terminalId}"]`);
-    const tabExists = await terminalTab.isVisible({ timeout: 5_000 }).catch(() => false);
-
-    if (tabExists) {
-      await terminalTab.click();
-    } else {
-      // Terminal tab not yet created — click "New terminal tab" to create one through the UI
-      const newTerminalBtn = page.getByRole("button", { name: "New terminal tab" });
-      await newTerminalBtn.waitFor({ state: "visible", timeout: 10_000 });
-      await newTerminalBtn.click();
-    }
-  }
-
-  // Wait for terminal surface to be visible
-  await terminalSurface.waitFor({ state: "visible", timeout: 15_000 });
-
-  // Wait for loading overlay to disappear (terminal attached)
-  await page
-    .locator('[data-testid="terminal-attach-loading"]')
-    .waitFor({ state: "hidden", timeout: 10_000 })
-    .catch(() => {
-      // overlay may never appear if attachment is instant
-    });
-
-  await terminalSurface.click();
-}
-
-export async function setupDeterministicPrompt(page: Page, sentinel?: string): Promise<void> {
-  const tag = sentinel ?? `READY_${Date.now()}`;
-  const terminal = page.locator('[data-testid="terminal-surface"]');
-
-  await terminal.pressSequentially(`echo ${tag}\n`, { delay: 0 });
-  await waitForTerminalContent(page, (text) => text.includes(tag), 10_000);
-
-  await terminal.pressSequentially("export PS1='$ '\n", { delay: 0 });
-  await page.waitForTimeout(300);
-}
-
-export type LatencySample = {
-  char: string;
-  latencyMs: number;
-};
-
-/**
- * Measures keystroke echo round-trip latency.
- *
- * Starts a high-resolution timer on the browser keydown event (capture phase)
- * and stops it when xterm.js finishes parsing the echoed write. This measures
- * the full path: keydown → WebSocket → daemon PTY echo → WebSocket → xterm render.
- */
-export async function measureKeystrokeLatency(page: Page, char: string): Promise<number> {
-  await page.evaluate(() => {
-    const term = (window as any).__paseoTerminal;
-    if (!term) {
-      throw new Error("__paseoTerminal not available");
-    }
-
-    const state = ((window as any).__perfKeystroke = {
-      promise: null as Promise<number> | null,
-    });
-
-    state.promise = new Promise<number>((resolve, reject) => {
-      const timeout = setTimeout(() => {
-        document.removeEventListener("keydown", onKeyDown, true);
-        reject(new Error("keystroke echo timeout (5s)"));
-      }, 5000);
-
-      function onKeyDown() {
-        document.removeEventListener("keydown", onKeyDown, true);
-        const start = performance.now();
-        const disposable = term.onWriteParsed(() => {
-          clearTimeout(timeout);
-          disposable.dispose();
-          resolve(performance.now() - start);
-        });
-      }
-
-      document.addEventListener("keydown", onKeyDown, true);
-    });
-  });
-
-  await page.keyboard.press(char);
-
-  return page.evaluate(() => (window as any).__perfKeystroke.promise);
-}
-
-export function computePercentile(samples: number[], p: number): number {
-  const sorted = [...samples].sort((a, b) => a - b);
-  const index = Math.ceil((p / 100) * sorted.length) - 1;
-  return sorted[Math.max(0, index)];
-}
-
-export function round2(value: number): number {
-  return Math.round(value * 100) / 100;
-}
@@ -1,160 +0,0 @@
-import { test, expect } from "./fixtures";
-import { createTempGitRepo } from "./helpers/workspace";
-import {
-  connectTerminalClient,
-  navigateToTerminal,
-  setupDeterministicPrompt,
-  waitForTerminalContent,
-  measureKeystrokeLatency,
-  computePercentile,
-  round2,
-  type TerminalPerfDaemonClient,
-  type LatencySample,
-} from "./helpers/terminal-perf";
-
-const LINE_COUNT = 50_000;
-const THROUGHPUT_BUDGET_MS = 30_000;
-const KEYSTROKE_SAMPLE_COUNT = 20;
-const KEYSTROKE_P95_BUDGET_MS = 150;
-
-test.describe("Terminal wire performance", () => {
-  let client: TerminalPerfDaemonClient;
-  let tempRepo: { path: string; cleanup: () => Promise<void> };
-
-  test.beforeAll(async () => {
-    tempRepo = await createTempGitRepo("perf-");
-    client = await connectTerminalClient();
-  });
-
-  test.afterAll(async () => {
-    if (client) {
-      await client.close();
-    }
-    if (tempRepo) {
-      await tempRepo.cleanup();
-    }
-  });
-
-  test("throughput: bulk terminal output renders within budget", async ({ page }, testInfo) => {
-    test.setTimeout(90_000);
-
-    const result = await client.createTerminal(tempRepo.path, "throughput");
-    if (!result.terminal) {
-      throw new Error(`Failed to create terminal: ${result.error}`);
-    }
-    const terminalId = result.terminal.id;
-
-    try {
-      await navigateToTerminal(page, { cwd: tempRepo.path, terminalId });
-      await setupDeterministicPrompt(page);
-
-      const sentinel = `PERF_DONE_${Date.now()}`;
-      const terminal = page.locator('[data-testid="terminal-surface"]');
-      const startMs = Date.now();
-
-      await terminal.pressSequentially(`seq 1 ${LINE_COUNT}; echo ${sentinel}\n`, { delay: 0 });
-
-      await waitForTerminalContent(page, (text) => text.includes(sentinel), THROUGHPUT_BUDGET_MS + 15_000);
-
-      const elapsedMs = Date.now() - startMs;
-
-      // seq 1 N outputs each number on its own line
-      const estimatedBytes = Array.from(
-        { length: LINE_COUNT },
-        (_, i) => String(i + 1).length + 1,
-      ).reduce((a, b) => a + b, 0);
-      const throughputMBps = estimatedBytes / (1024 * 1024) / (elapsedMs / 1000);
-
-      const report = {
-        lineCount: LINE_COUNT,
-        estimatedBytes,
-        elapsedMs,
-        throughputMBps: round2(throughputMBps),
-      };
-
-      await testInfo.attach("throughput-report", {
-        body: JSON.stringify(report, null, 2),
-        contentType: "application/json",
-      });
-
-      console.log(
-        `[perf] Throughput: ${report.throughputMBps} MB/s — ${LINE_COUNT} lines in ${elapsedMs}ms`,
-      );
-
-      expect(elapsedMs, `${LINE_COUNT} lines should render within ${THROUGHPUT_BUDGET_MS}ms`).toBeLessThan(
-        THROUGHPUT_BUDGET_MS,
-      );
-    } finally {
-      await client.killTerminal(terminalId).catch(() => {});
-    }
-  });
-
-  test("keystroke latency: echo round-trip under budget", async ({ page }, testInfo) => {
-    test.setTimeout(60_000);
-
-    const result = await client.createTerminal(tempRepo.path, "latency");
-    if (!result.terminal) {
-      throw new Error(`Failed to create terminal: ${result.error}`);
-    }
-    const terminalId = result.terminal.id;
-
-    try {
-      await navigateToTerminal(page, { cwd: tempRepo.path, terminalId });
-      await setupDeterministicPrompt(page);
-
-      // Ensure clean prompt state
-      const terminal = page.locator('[data-testid="terminal-surface"]');
-      await terminal.press("Control+c");
-      await page.waitForTimeout(200);
-
-      const samples: LatencySample[] = [];
-      const chars = "abcdefghijklmnopqrst";
-
-      for (let i = 0; i < KEYSTROKE_SAMPLE_COUNT; i++) {
-        const char = chars[i % chars.length];
-        const latencyMs = await measureKeystrokeLatency(page, char);
-        samples.push({ char, latencyMs });
-        await page.waitForTimeout(50);
-      }
-
-      // Clean up typed characters
-      await terminal.press("Control+c");
-
-      const latencies = samples.map((s) => s.latencyMs);
-      const p50 = computePercentile(latencies, 50);
-      const p95 = computePercentile(latencies, 95);
-      const max = Math.max(...latencies);
-      const min = Math.min(...latencies);
-      const avg = latencies.reduce((a, b) => a + b, 0) / latencies.length;
-
-      const report = {
-        sampleCount: KEYSTROKE_SAMPLE_COUNT,
-        p50Ms: round2(p50),
-        p95Ms: round2(p95),
-        maxMs: round2(max),
-        minMs: round2(min),
-        avgMs: round2(avg),
-        samples: samples.map((s) => ({
-          char: s.char,
-          latencyMs: round2(s.latencyMs),
-        })),
-      };
-
-      await testInfo.attach("latency-report", {
-        body: JSON.stringify(report, null, 2),
-        contentType: "application/json",
-      });
-
-      console.log(
-        `[perf] Keystroke latency — p50: ${report.p50Ms}ms, p95: ${report.p95Ms}ms, max: ${report.maxMs}ms`,
-      );
-
-      expect(
-        p95,
-        `Keystroke p95 latency should be under ${KEYSTROKE_P95_BUDGET_MS}ms`,
-      ).toBeLessThan(KEYSTROKE_P95_BUDGET_MS);
-    } finally {
-      await client.killTerminal(terminalId).catch(() => {});
-    }
-  });
-});
@@ -1,7 +1,7 @@
 {
  "name": "@getpaseo/app",
  "main": "index.ts",
-  "version": "0.1.37",
+  "version": "0.1.33",
  "private": true,
  "scripts": {
    "start": "expo start",
@@ -31,9 +31,9 @@
    "@dnd-kit/utilities": "^3.2.2",
    "@expo/vector-icons": "^15.0.2",
    "@floating-ui/react-native": "^0.10.7",
-    "@getpaseo/expo-two-way-audio": "0.1.37",
-    "@getpaseo/highlight": "0.1.37",
-    "@getpaseo/server": "0.1.37",
+    "@getpaseo/expo-two-way-audio": "0.1.33",
+    "@getpaseo/highlight": "0.1.33",
+    "@getpaseo/server": "0.1.33",
    "@gorhom/bottom-sheet": "^5.2.6",
    "@gorhom/portal": "^1.0.14",
    "@react-native-async-storage/async-storage": "2.2.0",
@@ -0,0 +1,36 @@
+export const WELCOME_ROUTE = "/welcome";
+
+export function shouldWaitOnStartupRace(input: {
+  onlineServerId: string | null;
+  hasTimedOut: boolean;
+  isDesktopStartupRace: boolean;
+  daemonCount: number;
+  pathname: string;
+}): boolean {
+  if (input.onlineServerId) {
+    return false;
+  }
+  if (input.pathname === WELCOME_ROUTE) {
+    return false;
+  }
+  if (input.hasTimedOut) {
+    return false;
+  }
+  return input.isDesktopStartupRace || input.daemonCount > 0;
+}
+
+export function shouldRedirectToWelcome(input: {
+  onlineServerId: string | null;
+  hasTimedOut: boolean;
+  pathname: string;
+  isDesktopStartupRace: boolean;
+  daemonCount: number;
+}): boolean {
+  if (input.onlineServerId || !input.hasTimedOut) {
+    return false;
+  }
+  if (input.pathname !== "/" && input.pathname !== "") {
+    return false;
+  }
+  return input.isDesktopStartupRace || input.daemonCount > 0;
+}
@@ -25,9 +25,6 @@ import {
  useHostMutations,
  useHostRuntimeClient,
 } from "@/runtime/host-runtime";
-import { shouldUseDesktopDaemon } from "@/desktop/daemon/desktop-daemon";
-import { StartupSplashScreen } from "@/screens/startup-splash-screen";
-import { loadSettingsFromStorage } from "@/hooks/use-settings";
 import { SessionProvider } from "@/contexts/session-context";
 import type { HostProfile } from "@/types/host-connection";
 import {
@@ -213,22 +210,14 @@ function HostRuntimeBootstrapProvider({ children }: { children: ReactNode }) {
    let cancelled = false;
    const store = getHostRuntimeStore();

-    const init = async () => {
-      const settings = await loadSettingsFromStorage();
-      const isDesktopManaged = shouldUseDesktopDaemon() && settings.manageBuiltInDaemon;
-      await store.loadFromStorage();
-      if (isDesktopManaged) {
-        await store.bootstrap({ manageBuiltInDaemon: true });
-      } else {
-        void store.bootstrap({ manageBuiltInDaemon: settings.manageBuiltInDaemon });
-      }
-    };
-
-    void init()
+    void store
+      .loadFromStorage()
      .then(() => {
-        if (!cancelled) {
-          setReady(true);
+        if (cancelled) {
+          return;
        }
+        setReady(true);
+        void store.bootstrap();
      })
      .catch((error) => {
        console.error("[HostRuntime] Failed to initialize store", error);
@@ -426,9 +415,7 @@ function ProvidersWrapper({ children }: { children: ReactNode }) {
  }, [isLoading, settings.theme]);

  if (isLoading) {
-    const isDesktopManaged =
-      !settingsLoading && shouldUseDesktopDaemon() && settings.manageBuiltInDaemon;
-    return isDesktopManaged ? <StartupSplashScreen /> : <LoadingView />;
+    return <LoadingView />;
  }

  return (
@@ -1,18 +1,113 @@
-import { useEffect } from "react";
+import { useEffect, useSyncExternalStore, useState } from "react";
 import { usePathname, useRouter } from "expo-router";
+import { useHosts } from "@/runtime/host-runtime";
+import { shouldUseDesktopDaemon } from "@/desktop/daemon/desktop-daemon";
+import { buildHostRootRoute } from "@/utils/host-routes";
+import { StartupSplashScreen } from "@/screens/startup-splash-screen";
+import { WelcomeScreen } from "@/components/welcome-screen";
+import { getHostRuntimeStore, isHostRuntimeConnected } from "@/runtime/host-runtime";
+import {
+  shouldRedirectToWelcome,
+  shouldWaitOnStartupRace,
+  WELCOME_ROUTE,
+} from "@/app-support/index-startup";

-const WELCOME_ROUTE = "/welcome";
+const STARTUP_TIMEOUT_MS = 30_000;
+function useAnyHostOnline(serverIds: string[]): string | null {
+  const runtime = getHostRuntimeStore();
+  return useSyncExternalStore(
+    (onStoreChange) => runtime.subscribeAll(onStoreChange),
+    () => {
+      let firstOnlineServerId: string | null = null;
+      let firstOnlineAt: string | null = null;
+      for (const serverId of serverIds) {
+        const snapshot = runtime.getSnapshot(serverId);
+        const lastOnlineAt = snapshot?.lastOnlineAt ?? null;
+        if (!isHostRuntimeConnected(snapshot) || !lastOnlineAt) {
+          continue;
+        }
+        if (!firstOnlineAt || lastOnlineAt < firstOnlineAt) {
+          firstOnlineAt = lastOnlineAt;
+          firstOnlineServerId = serverId;
+        }
+      }
+      return firstOnlineServerId;
+    },
+    () => {
+      let firstOnlineServerId: string | null = null;
+      let firstOnlineAt: string | null = null;
+      for (const serverId of serverIds) {
+        const snapshot = runtime.getSnapshot(serverId);
+        const lastOnlineAt = snapshot?.lastOnlineAt ?? null;
+        if (!isHostRuntimeConnected(snapshot) || !lastOnlineAt) {
+          continue;
+        }
+        if (!firstOnlineAt || lastOnlineAt < firstOnlineAt) {
+          firstOnlineAt = lastOnlineAt;
+          firstOnlineServerId = serverId;
+        }
+      }
+      return firstOnlineServerId;
+    },
+  );
+}

 export default function Index() {
  const router = useRouter();
  const pathname = usePathname();
+  const daemons = useHosts();
+  const [hasTimedOut, setHasTimedOut] = useState(false);
+  const isDesktopStartupRace = shouldUseDesktopDaemon();
+  const onlineServerId = useAnyHostOnline(daemons.map((daemon) => daemon.serverId));
+  useEffect(() => {
+    const timer = setTimeout(() => {
+      setHasTimedOut(true);
+    }, STARTUP_TIMEOUT_MS);
+    return () => {
+      clearTimeout(timer);
+    };
+  }, []);

  useEffect(() => {
+    if (!onlineServerId) {
+      return;
+    }
    if (pathname !== "/" && pathname !== "") {
      return;
    }
+    router.replace(buildHostRootRoute(onlineServerId) as any);
+  }, [onlineServerId, pathname, router]);
+
+  useEffect(() => {
+    if (
+      !shouldRedirectToWelcome({
+        onlineServerId,
+        hasTimedOut,
+        pathname,
+        isDesktopStartupRace,
+        daemonCount: daemons.length,
+      })
+    ) {
+      return;
+    }
    router.replace(WELCOME_ROUTE as any);
-  }, [pathname, router]);
+  }, [daemons.length, hasTimedOut, isDesktopStartupRace, onlineServerId, pathname, router]);
+
+  if (
+    shouldWaitOnStartupRace({
+      onlineServerId,
+      hasTimedOut,
+      isDesktopStartupRace,
+      daemonCount: daemons.length,
+      pathname,
+    })
+  ) {
+    return <StartupSplashScreen />;
+  }
+
+  if (!onlineServerId) {
+    return <WelcomeScreen />;
+  }

  return null;
 }
@@ -6,6 +6,7 @@ import {
  HEADER_INNER_HEIGHT,
  HEADER_INNER_HEIGHT_MOBILE,
  HEADER_TOP_PADDING_MOBILE,
+  getIsDesktopMac,
 } from "@/constants/layout";
 import { useDesktopDragHandlers, useTrafficLightPadding } from "@/utils/desktop-window";
 import { usePanelStore } from "@/stores/panel-store";
@@ -30,10 +31,8 @@ export function ScreenHeader({ left, right, leftStyle, rightStyle }: ScreenHeade
  // Only add extra padding on mobile for better touch targets; on desktop, only use safe area insets
  const topPadding = isMobile ? HEADER_TOP_PADDING_MOBILE : 0;
  const baseHorizontalPadding = theme.spacing[2];
-  const collapsedSidebarInset =
-    !isMobile && !desktopAgentListOpen && trafficLightPadding.side
-      ? trafficLightPadding
-      : { left: 0, right: 0 };
+  const collapsedSidebarTrafficLightInset =
+    !isMobile && !desktopAgentListOpen && getIsDesktopMac() ? trafficLightPadding.left : 0;

  const dragHandlers = useDesktopDragHandlers();

@@ -43,10 +42,7 @@ export function ScreenHeader({ left, right, leftStyle, rightStyle }: ScreenHeade
        <View
          style={[
            styles.row,
-            {
-              paddingLeft: baseHorizontalPadding + collapsedSidebarInset.left,
-              paddingRight: baseHorizontalPadding + collapsedSidebarInset.right,
-            },
+            { paddingLeft: baseHorizontalPadding + collapsedSidebarTrafficLightInset },
          ]}
          {...dragHandlers}
        >
@@ -681,7 +681,7 @@ function DesktopSidebar({

  return (
    <Animated.View style={[styles.desktopSidebar, resizeAnimatedStyle]}>
-      {trafficLightPadding.side === 'left' ? (
+      {trafficLightPadding.top > 0 ? (
        <View style={{ height: trafficLightPadding.top }} {...dragHandlers} />
      ) : null}
      <View style={styles.sidebarHeader} {...dragHandlers}>
@@ -346,13 +346,9 @@ export const MessageInput = forwardRef<MessageInputRef, MessageInputProps>(funct
    [onChangeText, onSubmit, images, isAgentRunning],
  );

-  const handleDictationError = useCallback(
-    (error: Error) => {
-      console.error("[MessageInput] Dictation error:", error);
-      toast.error(error.message);
-    },
-    [toast],
-  );
+  const handleDictationError = useCallback((error: Error) => {
+    console.error("[MessageInput] Dictation error:", error);
+  }, []);

  const dictationUnavailableMessage = resolveVoiceUnavailableMessage({
    serverInfo,
@@ -954,20 +950,18 @@ export const MessageInput = forwardRef<MessageInputRef, MessageInputProps>(funct
          <View style={styles.leftButtonGroup}>
            {onPickImages && (
              <Tooltip delayDuration={0} enabledOnDesktop enabledOnMobile={false}>
-                <TooltipTrigger asChild>
-                  <Pressable
-                    onPress={onPickImages}
-                    disabled={!isConnected || disabled}
-                    accessibilityLabel="Attach images"
-                    accessibilityRole="button"
-                    style={({ hovered }) => [
-                      styles.attachButton,
-                      hovered && styles.iconButtonHovered,
-                      (!isConnected || disabled) && styles.buttonDisabled,
-                    ]}
-                  >
-                    <Paperclip size={buttonIconSize} color={theme.colors.foreground} />
-                  </Pressable>
+                <TooltipTrigger
+                  onPress={onPickImages}
+                  disabled={!isConnected || disabled}
+                  accessibilityLabel="Attach images"
+                  accessibilityRole="button"
+                  style={({ hovered }) => [
+                    styles.attachButton,
+                    hovered && styles.iconButtonHovered,
+                    (!isConnected || disabled) && styles.buttonDisabled,
+                  ]}
+                >
+                  <Paperclip size={buttonIconSize} color={theme.colors.foreground} />
                </TooltipTrigger>
                <TooltipContent side="top" align="center" offset={8}>
                  <Text style={styles.tooltipText}>Attach images</Text>
@@ -1209,7 +1203,7 @@ const styles = StyleSheet.create(((theme: any) => ({
  leftButtonGroup: {
    flexDirection: "row",
    alignItems: "flex-end",
-    gap: theme.spacing[1],
+    gap: Platform.OS === "web" ? theme.spacing[2] : theme.spacing[1],
  },
  rightButtonGroup: {
    flexDirection: "row",
@@ -31,11 +31,11 @@ import {
  ChevronRight,
  Copy,
  ExternalLink,
-  FolderPlus,
  FolderGit2,
  GitPullRequest,
  Monitor,
  MoreVertical,
+  Plus,
 } from "lucide-react-native";
 import { NestableScrollContainer } from "react-native-draggable-flatlist";
 import { DraggableList, type DraggableRenderItemInfo } from "./draggable-list";
@@ -392,15 +392,15 @@ function NewWorktreeButton({
            }}
            disabled={loading}
            accessibilityRole="button"
-            accessibilityLabel={`Create a new workspace for ${displayName}`}
+            accessibilityLabel={`Create a new worktree for ${displayName}`}
            testID={testID}
          >
            {({ hovered, pressed }) =>
              loading ? (
                <ActivityIndicator size={14} color={theme.colors.foregroundMuted} />
              ) : (
-                <FolderPlus
-                  size={15}
+                <Plus
+                  size={14}
                  color={
                    hovered || pressed ? theme.colors.foreground : theme.colors.foregroundMuted
                  }
@@ -411,7 +411,7 @@ function NewWorktreeButton({
        </TooltipTrigger>
        <TooltipContent side="bottom" align="center" offset={8}>
          <View style={styles.projectActionTooltipRow}>
-            <Text style={styles.projectActionTooltipText}>New workspace</Text>
+            <Text style={styles.projectActionTooltipText}>New worktree</Text>
            {showShortcutHint && newWorktreeKeys ? (
              <Shortcut chord={newWorktreeKeys} style={styles.projectActionTooltipShortcut} />
            ) : null}
@@ -886,10 +886,7 @@ function SplitPaneView({
        style={[
          styles.paneTabs,
          isFocusModeEnabled &&
-            trafficLightPadding.side && {
-              paddingLeft: trafficLightPadding.left,
-              paddingRight: trafficLightPadding.right,
-            },
+            trafficLightPadding.left > 0 && { paddingLeft: trafficLightPadding.left },
        ]}
      >
        <WorkspaceDesktopTabsRow
@@ -1,17 +1,11 @@
-import { useCallback, useEffect, useState, useSyncExternalStore } from "react";
+import { useCallback, useState } from "react";
 import { Pressable, Text, View, Platform, ScrollView } from "react-native";
 import { useRouter } from "expo-router";
 import { StyleSheet, useUnistyles } from "react-native-unistyles";
 import { QrCode, Link2, ClipboardPaste } from "lucide-react-native";
 import { useSafeAreaInsets } from "react-native-safe-area-context";
 import type { HostProfile } from "@/types/host-connection";
-import {
-  getHostRuntimeStore,
-  isHostRuntimeConnected,
-  useHostMutations,
-  useHostRuntimeSnapshot,
-  useHosts,
-} from "@/runtime/host-runtime";
+import { useHostMutations } from "@/runtime/host-runtime";
 import { useSessionStore } from "@/stores/session-store";
 import { AddHostModal } from "./add-host-modal";
 import { PairLinkModal } from "./pair-link-modal";
@@ -85,39 +79,6 @@ const styles = StyleSheet.create((theme) => ({
  actionTextPrimary: {
    color: theme.colors.accentForeground,
  },
-  hostList: {
-    width: "100%",
-    maxWidth: 420,
-    marginTop: theme.spacing[6],
-    borderTopWidth: 1,
-    borderTopColor: theme.colors.border,
-    paddingTop: theme.spacing[4],
-    gap: theme.spacing[2],
-  },
-  hostRow: {
-    flexDirection: "row",
-    alignItems: "center",
-    gap: theme.spacing[3],
-    paddingVertical: theme.spacing[2],
-  },
-  statusDot: {
-    width: 8,
-    height: 8,
-    borderRadius: 4,
-  },
-  hostLabel: {
-    flex: 1,
-    color: theme.colors.foreground,
-    fontSize: theme.fontSize.sm,
-  },
-  hostStatus: {
-    color: theme.colors.foregroundMuted,
-    fontSize: theme.fontSize.sm,
-  },
-  hostStatusError: {
-    color: theme.colors.destructive,
-    fontSize: theme.fontSize.sm,
-  },
  versionLabel: {
    color: theme.colors.foregroundMuted,
    fontSize: theme.fontSize.xs,
@@ -126,89 +87,6 @@ const styles = StyleSheet.create((theme) => ({
  },
 }));

-function useAnyHostOnline(serverIds: string[]): string | null {
-  const runtime = getHostRuntimeStore();
-  return useSyncExternalStore(
-    (onStoreChange) => runtime.subscribeAll(onStoreChange),
-    () => {
-      let firstOnlineServerId: string | null = null;
-      let firstOnlineAt: string | null = null;
-      for (const serverId of serverIds) {
-        const snapshot = runtime.getSnapshot(serverId);
-        const lastOnlineAt = snapshot?.lastOnlineAt ?? null;
-        if (!isHostRuntimeConnected(snapshot) || !lastOnlineAt) {
-          continue;
-        }
-        if (!firstOnlineAt || lastOnlineAt < firstOnlineAt) {
-          firstOnlineAt = lastOnlineAt;
-          firstOnlineServerId = serverId;
-        }
-      }
-      return firstOnlineServerId;
-    },
-    () => {
-      let firstOnlineServerId: string | null = null;
-      let firstOnlineAt: string | null = null;
-      for (const serverId of serverIds) {
-        const snapshot = runtime.getSnapshot(serverId);
-        const lastOnlineAt = snapshot?.lastOnlineAt ?? null;
-        if (!isHostRuntimeConnected(snapshot) || !lastOnlineAt) {
-          continue;
-        }
-        if (!firstOnlineAt || lastOnlineAt < firstOnlineAt) {
-          firstOnlineAt = lastOnlineAt;
-          firstOnlineServerId = serverId;
-        }
-      }
-      return firstOnlineServerId;
-    },
-  );
-}
-
-function HostStatusRow({ serverId, label }: { serverId: string; label: string }) {
-  const { theme } = useUnistyles();
-  const snapshot = useHostRuntimeSnapshot(serverId);
-  const status = snapshot?.connectionStatus ?? "connecting";
-  const lastError = snapshot?.lastError ?? null;
-
-  let dotColor: string;
-  let statusText: string;
-  let isError = false;
-
-  switch (status) {
-    case "online":
-      dotColor = theme.colors.success;
-      statusText = "Online";
-      break;
-    case "connecting":
-    case "idle":
-      dotColor = theme.colors.foregroundMuted;
-      statusText = "Connecting…";
-      break;
-    case "offline":
-      dotColor = theme.colors.foregroundMuted;
-      statusText = "Offline";
-      break;
-    case "error":
-      dotColor = theme.colors.destructive;
-      statusText = lastError ? lastError.slice(0, 40) : "Connection error";
-      isError = true;
-      break;
-  }
-
-  return (
-    <View style={styles.hostRow}>
-      <View style={[styles.statusDot, { backgroundColor: dotColor }]} />
-      <Text style={styles.hostLabel} numberOfLines={1}>
-        {label}
-      </Text>
-      <Text style={isError ? styles.hostStatusError : styles.hostStatus} numberOfLines={1}>
-        {statusText}
-      </Text>
-    </View>
-  );
-}
-
 export interface WelcomeScreenProps {
  onHostAdded?: (profile: HostProfile) => void;
 }
@@ -227,8 +105,6 @@ export function WelcomeScreen({ onHostAdded }: WelcomeScreenProps) {
    hostname: string | null;
  } | null>(null);
  const [pendingRedirectServerId, setPendingRedirectServerId] = useState<string | null>(null);
-  const hosts = useHosts();
-  const anyOnlineServerId = useAnyHostOnline(hosts.map((h) => h.serverId));
  const pendingNameHostname = useSessionStore(
    useCallback(
      (state) => {
@@ -243,16 +119,6 @@ export function WelcomeScreen({ onHostAdded }: WelcomeScreenProps) {
    ),
  );

-  useEffect(() => {
-    if (!anyOnlineServerId) {
-      return;
-    }
-    if (pendingNameHost) {
-      return;
-    }
-    router.replace(buildHostRootRoute(anyOnlineServerId) as any);
-  }, [anyOnlineServerId, pendingNameHost, router]);
-
  const finishOnboarding = useCallback(
    (serverId: string) => {
      router.replace(buildHostRootRoute(serverId) as any);
@@ -307,8 +173,6 @@ export function WelcomeScreen({ onHostAdded }: WelcomeScreenProps) {
          },
        ];

-  const showHostList = hosts.length > 0 && !anyOnlineServerId;
-
  return (
    <ScrollView
      style={{ flex: 1, backgroundColor: theme.colors.surface0 }}
@@ -322,9 +186,7 @@ export function WelcomeScreen({ onHostAdded }: WelcomeScreenProps) {
      <View style={styles.content}>
        <PaseoLogo size={96} color={theme.colors.foreground} />
        <Text style={styles.title}>Welcome to Paseo</Text>
-        <Text style={styles.subtitle}>
-          {showHostList ? "Connecting to your hosts…" : "Connect to your host to start"}
-        </Text>
+        <Text style={styles.subtitle}>Connect to your host to start</Text>

        <View style={styles.actions}>
          {actions.map((action) => {
@@ -347,14 +209,6 @@ export function WelcomeScreen({ onHostAdded }: WelcomeScreenProps) {
            );
          })}
        </View>
-
-        {showHostList && (
-          <View style={styles.hostList}>
-            {hosts.map((host) => (
-              <HostStatusRow key={host.serverId} serverId={host.serverId} label={host.label} />
-            ))}
-          </View>
-        )}
      </View>
      <Text style={styles.versionLabel}>{appVersionText}</Text>

@@ -19,10 +19,6 @@ export const MAX_CONTENT_WIDTH = 820;
 export const DESKTOP_TRAFFIC_LIGHT_WIDTH = 78;
 export const DESKTOP_TRAFFIC_LIGHT_HEIGHT = 45;

-// Windows/Linux window controls (minimize/maximize/close) — top-right
-export const DESKTOP_WINDOW_CONTROLS_WIDTH = 140;
-export const DESKTOP_WINDOW_CONTROLS_HEIGHT = 48;
-
 // Check if running in desktop app (any OS)
 function isDesktopEnvironment(): boolean {
  if (Platform.OS !== "web") return false;
@@ -49,7 +49,6 @@ import { derivePendingPermissionKey, normalizeAgentSnapshot } from "@/utils/agen
 import { resolveProjectPlacement } from "@/utils/project-placement";
 import { buildDraftStoreKey } from "@/stores/draft-keys";
 import type { AttachmentMetadata } from "@/attachments/types";
-import { reconcilePreviousAgentStatuses } from "@/contexts/session-status-tracking";

 // Re-export types from session-store and draft-store for backward compatibility
 export type { DraftInput } from "@/stores/draft-store";
@@ -296,10 +295,15 @@ function SessionProviderInternal({ children, serverId, client }: SessionProvider
  }, []);

  useEffect(() => {
-    previousAgentStatusRef.current = reconcilePreviousAgentStatuses(
-      previousAgentStatusRef.current,
-      sessionAgents,
-    );
+    if (!sessionAgents) {
+      previousAgentStatusRef.current.clear();
+      return;
+    }
+    const nextStatuses = new Map<string, AgentLifecycleStatus>();
+    for (const nextAgent of sessionAgents.values()) {
+      nextStatuses.set(nextAgent.id, nextAgent.status);
+    }
+    previousAgentStatusRef.current = nextStatuses;
  }, [sessionAgents]);

  const hydrateWorkspaces = useCallback(
@@ -521,9 +525,8 @@ function SessionProviderInternal({ children, serverId, client }: SessionProvider
          void client
            .fetchAgentTimeline(agentId, {
              direction: "after",
-              cursor: { epoch: cursor.epoch, seq: cursor.endSeq },
+              cursor: { seq: cursor.endSeq },
              limit: 0,
-              projection: "canonical",
            })
            .catch((error) => {
              console.warn("[Session] failed to fetch catch-up timeline on resume", agentId, error);
@@ -749,13 +752,12 @@ function SessionProviderInternal({ children, serverId, client }: SessionProvider
  );

  const requestCanonicalCatchUp = useCallback(
-    (agentId: string, cursor: { epoch: string; endSeq: number }) => {
+    (agentId: string, cursor: { endSeq: number }) => {
      void client
        .fetchAgentTimeline(agentId, {
          direction: "after",
-          cursor: { epoch: cursor.epoch, seq: cursor.endSeq },
+          cursor: { seq: cursor.endSeq },
          limit: 0,
-          projection: "canonical",
        })
        .catch((error) => {
          console.warn("[Session] failed to fetch canonical catch-up timeline", agentId, error);
@@ -858,7 +860,6 @@ function SessionProviderInternal({ children, serverId, client }: SessionProvider
          }
          if (
            current &&
-            current.epoch === result.cursor.epoch &&
            current.startSeq === result.cursor.startSeq &&
            current.endSeq === result.cursor.endSeq
          ) {
@@ -963,7 +964,7 @@ function SessionProviderInternal({ children, serverId, client }: SessionProvider

    const unsubAgentStream = client.on("agent_stream", (message) => {
      if (message.type !== "agent_stream") return;
-      const { agentId, event, timestamp, seq, epoch } = message.payload;
+      const { agentId, event, timestamp, seq } = message.payload;
      const parsedTimestamp = new Date(timestamp);
      const streamEvent = event as AgentStreamEventPayload;
      if (
@@ -1005,7 +1006,6 @@ function SessionProviderInternal({ children, serverId, client }: SessionProvider
      const result = processAgentStreamEvent({
        event: streamEvent,
        seq,
-        epoch,
        currentTail,
        currentHead,
        currentCursor,
@@ -1029,8 +1029,6 @@ function SessionProviderInternal({ children, serverId, client }: SessionProvider
          if (
            current &&
            typeof seq === "number" &&
-            typeof epoch === "string" &&
-            current.epoch === epoch &&
            seq >= current.startSeq &&
            seq <= current.endSeq
          ) {
@@ -1039,7 +1037,6 @@ function SessionProviderInternal({ children, serverId, client }: SessionProvider
          }
          if (
            current &&
-            current.epoch === nextCursor.epoch &&
            current.startSeq === nextCursor.startSeq &&
            current.endSeq === nextCursor.endSeq
          ) {
@@ -1,72 +0,0 @@
-import { describe, expect, it } from "vitest";
-import type { Agent } from "@/stores/session-store";
-import { reconcilePreviousAgentStatuses } from "./session-status-tracking";
-
-function createAgent(status: Agent["status"]): Agent {
-  return {
-    serverId: "server-1",
-    id: "agent-1",
-    provider: "codex",
-    status,
-    createdAt: new Date(0),
-    updatedAt: new Date(0),
-    lastUserMessageAt: null,
-    lastActivityAt: new Date(0),
-    capabilities: {
-      supportsStreaming: true,
-      supportsSessionPersistence: true,
-      supportsDynamicModes: true,
-      supportsMcpServers: true,
-      supportsReasoningStream: true,
-      supportsToolInvocations: true,
-    },
-    currentModeId: null,
-    availableModes: [],
-    pendingPermissions: [],
-    persistence: null,
-    title: "Agent",
-    cwd: "/tmp",
-    model: null,
-    labels: {},
-    projectPlacement: null,
-  };
-}
-
-describe("reconcilePreviousAgentStatuses", () => {
-  it("preserves previously seen status for existing agents", () => {
-    const previous = new Map([["agent-1", "running" as const]]);
-    const sessionAgents = new Map([["agent-1", createAgent("idle")]]);
-
-    const result = reconcilePreviousAgentStatuses(previous, sessionAgents);
-
-    expect(result).toEqual(new Map([["agent-1", "running"]]));
-  });
-
-  it("seeds newly seen agents from the current snapshot", () => {
-    const sessionAgents = new Map([["agent-1", createAgent("idle")]]);
-
-    const result = reconcilePreviousAgentStatuses(new Map(), sessionAgents);
-
-    expect(result).toEqual(new Map([["agent-1", "idle"]]));
-  });
-
-  it("removes agents that are no longer present", () => {
-    const previous = new Map([
-      ["agent-1", "running" as const],
-      ["agent-2", "idle" as const],
-    ]);
-    const sessionAgents = new Map([["agent-1", createAgent("idle")]]);
-
-    const result = reconcilePreviousAgentStatuses(previous, sessionAgents);
-
-    expect(result).toEqual(new Map([["agent-1", "running"]]));
-  });
-
-  it("clears all tracked statuses when the session is unavailable", () => {
-    const previous = new Map([["agent-1", "running" as const]]);
-
-    const result = reconcilePreviousAgentStatuses(previous, undefined);
-
-    expect(result).toEqual(new Map());
-  });
-});
@@ -1,29 +0,0 @@
-import type { AgentLifecycleStatus } from "@server/shared/agent-lifecycle";
-import type { Agent } from "@/stores/session-store";
-
-export function reconcilePreviousAgentStatuses(
-  previousStatuses: Map<string, AgentLifecycleStatus>,
-  sessionAgents: Map<string, Agent> | undefined,
-): Map<string, AgentLifecycleStatus> {
-  if (!sessionAgents) {
-    return new Map();
-  }
-
-  const nextStatuses = new Map(previousStatuses);
-  const seenAgentIds = new Set<string>();
-
-  for (const agent of sessionAgents.values()) {
-    seenAgentIds.add(agent.id);
-    if (!nextStatuses.has(agent.id)) {
-      nextStatuses.set(agent.id, agent.status);
-    }
-  }
-
-  for (const agentId of nextStatuses.keys()) {
-    if (!seenAgentIds.has(agentId)) {
-      nextStatuses.delete(agentId);
-    }
-  }
-
-  return nextStatuses;
-}
@@ -9,13 +9,9 @@ import {
  type TimelineCursor,
 } from "./session-stream-reducers";

-// ---------------------------------------------------------------------------
-// Test helpers
-// ---------------------------------------------------------------------------
-
 function makeTimelineEntry(seq: number, text: string, type: string = "assistant_message") {
  return {
-    seqStart: seq,
+    seq,
    provider: "claude",
    item: { type, text },
    timestamp: new Date(1000 + seq).toISOString(),
@@ -33,22 +29,30 @@ function makeTimelineEvent(
  } as AgentStreamEventPayload;
 }

-function makeUserTimelineEvent(text: string): AgentStreamEventPayload {
+function makeToolCallEvent(status: "running" | "completed"): AgentStreamEventPayload {
  return {
    type: "timeline",
    provider: "claude",
-    item: { type: "user_message", text },
-  } as AgentStreamEventPayload;
+    item: {
+      type: "tool_call",
+      callId: "call-1",
+      name: "shell",
+      status,
+      detail: {
+        type: "shell",
+        command: "pwd",
+      },
+      error: null,
+    },
+  };
 }

 const baseTimelineInput: ProcessTimelineResponseInput = {
  payload: {
    agentId: "agent-1",
    direction: "after",
-    reset: false,
-    epoch: "epoch-1",
-    startCursor: null,
-    endCursor: null,
+    startSeq: null,
+    endSeq: null,
    entries: [],
    error: null,
  },
@@ -63,7 +67,6 @@ const baseTimelineInput: ProcessTimelineResponseInput = {
 const baseStreamInput: ProcessAgentStreamEventInput = {
  event: makeTimelineEvent("hello"),
  seq: undefined,
-  epoch: undefined,
  currentTail: [],
  currentHead: [],
  currentCursor: undefined,
@@ -71,10 +74,6 @@ const baseStreamInput: ProcessAgentStreamEventInput = {
  timestamp: new Date(2000),
 };

-// ---------------------------------------------------------------------------
-// processTimelineResponse
-// ---------------------------------------------------------------------------
-
 describe("processTimelineResponse", () => {
  it("returns error path when payload.error is set", () => {
    const result = processTimelineResponse({
@@ -93,35 +92,10 @@ describe("processTimelineResponse", () => {
    expect(result.tail).toBe(baseTimelineInput.currentTail);
    expect(result.head).toBe(baseTimelineInput.currentHead);
    expect(result.cursorChanged).toBe(false);
-    expect(result.sideEffects).toEqual([]);
  });

-  it("returns error with no init resolution when no deferred exists", () => {
-    const result = processTimelineResponse({
-      ...baseTimelineInput,
-      isInitializing: true,
-      hasActiveInitDeferred: false,
-      payload: {
-        ...baseTimelineInput.payload,
-        error: "timeout",
-      },
-    });
-
-    expect(result.error).toBe("timeout");
-    expect(result.initResolution).toBe(null);
-    expect(result.clearInitializing).toBe(true);
-  });
-
-  it("replaces tail and clears head when reset=true", () => {
-    const existingTail: StreamItem[] = [
-      {
-        kind: "user_message",
-        id: "old",
-        text: "old message",
-        timestamp: new Date(500),
-      },
-    ];
-    const existingHead: StreamItem[] = [
+  it("replaces tail during bootstrap tail init and schedules committed catch-up", () => {
+    const provisionalHead: StreamItem[] = [
      {
        kind: "assistant_message",
        id: "head-1",
@@ -132,518 +106,280 @@ describe("processTimelineResponse", () => {

    const result = processTimelineResponse({
      ...baseTimelineInput,
-      currentTail: existingTail,
-      currentHead: existingHead,
-      payload: {
-        ...baseTimelineInput.payload,
-        reset: true,
-        startCursor: { seq: 1 },
-        endCursor: { seq: 3 },
-        entries: [
-          makeTimelineEntry(1, "first"),
-          makeTimelineEntry(2, "second"),
-          makeTimelineEntry(3, "third"),
-        ],
-      },
-    });
-
-    expect(result.tail).not.toBe(existingTail);
-    expect(result.tail.length).toBeGreaterThan(0);
-    expect(result.head).toEqual([]);
-    expect(result.cursorChanged).toBe(true);
-    expect(result.cursor).toEqual({
-      epoch: "epoch-1",
-      startSeq: 1,
-      endSeq: 3,
-    });
-    expect(result.error).toBe(null);
-    expect(result.sideEffects.some((e) => e.type === "flush_pending_updates")).toBe(true);
-  });
-
-  it("sets cursor to null when reset=true but no cursors in payload", () => {
-    const result = processTimelineResponse({
-      ...baseTimelineInput,
-      currentCursor: { epoch: "epoch-1", startSeq: 1, endSeq: 5 },
-      payload: {
-        ...baseTimelineInput.payload,
-        reset: true,
-        entries: [],
-      },
-    });
-
-    expect(result.cursor).toBe(null);
-    expect(result.cursorChanged).toBe(true);
-  });
-
-  it("performs bootstrap tail init with catch-up side effect", () => {
-    const result = processTimelineResponse({
-      ...baseTimelineInput,
+      currentHead: provisionalHead,
      isInitializing: true,
      hasActiveInitDeferred: true,
      initRequestDirection: "tail",
      payload: {
        ...baseTimelineInput.payload,
        direction: "tail",
-        epoch: "epoch-1",
-        startCursor: { seq: 1 },
-        endCursor: { seq: 5 },
+        startSeq: 1,
+        endSeq: 5,
        entries: [makeTimelineEntry(1, "first"), makeTimelineEntry(5, "last")],
      },
    });

-    // Bootstrap tail replaces
    expect(result.tail.length).toBeGreaterThan(0);
    expect(result.head).toEqual([]);
    expect(result.cursorChanged).toBe(true);
    expect(result.cursor).toEqual({
-      epoch: "epoch-1",
      startSeq: 1,
      endSeq: 5,
    });

-    // Should have catch-up side effect
-    const catchUp = result.sideEffects.find((e) => e.type === "catch_up");
-    expect(catchUp).toBeDefined();
-    expect(catchUp!.type === "catch_up" && catchUp!.cursor).toEqual({
-      epoch: "epoch-1",
-      endSeq: 5,
+    const catchUp = result.sideEffects.find((effect) => effect.type === "catch_up");
+    expect(catchUp).toEqual({
+      type: "catch_up",
+      cursor: { endSeq: 5 },
    });
  });

-  it("appends incrementally for contiguous seqs", () => {
-    const existingCursor: TimelineCursor = {
-      epoch: "epoch-1",
-      startSeq: 1,
-      endSeq: 3,
-    };
-
-    const result = processTimelineResponse({
-      ...baseTimelineInput,
-      currentCursor: existingCursor,
-      payload: {
-        ...baseTimelineInput.payload,
-        epoch: "epoch-1",
-        entries: [makeTimelineEntry(4, "next-1"), makeTimelineEntry(5, "next-2")],
+  it("prepends older committed history for before pagination", () => {
+    const currentTail: StreamItem[] = [
+      {
+        kind: "assistant_message",
+        id: "tail-3",
+        text: "newer",
+        timestamp: new Date(3000),
      },
-    });
-
-    expect(result.tail.length).toBeGreaterThan(0);
-    expect(result.cursorChanged).toBe(true);
-    expect(result.cursor).toEqual({
-      epoch: "epoch-1",
-      startSeq: 1,
-      endSeq: 5,
-    });
-    expect(result.error).toBe(null);
-  });
-
-  it("detects gap and emits catch-up side effect", () => {
-    const existingCursor: TimelineCursor = {
-      epoch: "epoch-1",
-      startSeq: 1,
-      endSeq: 3,
-    };
+    ];
+    const currentCursor: TimelineCursor = { startSeq: 3, endSeq: 4 };

    const result = processTimelineResponse({
      ...baseTimelineInput,
-      currentCursor: existingCursor,
-      payload: {
-        ...baseTimelineInput.payload,
-        epoch: "epoch-1",
-        entries: [makeTimelineEntry(10, "far ahead")],
-      },
-    });
-
-    // Gap should trigger catch-up
-    const catchUp = result.sideEffects.find((e) => e.type === "catch_up");
-    expect(catchUp).toBeDefined();
-    expect(catchUp!.type === "catch_up" && catchUp!.cursor).toEqual({
-      epoch: "epoch-1",
-      endSeq: 3,
-    });
-  });
-
-  it("drops stale entries silently", () => {
-    const existingCursor: TimelineCursor = {
-      epoch: "epoch-1",
-      startSeq: 1,
-      endSeq: 8,
-    };
-
-    const result = processTimelineResponse({
-      ...baseTimelineInput,
-      currentCursor: existingCursor,
-      payload: {
-        ...baseTimelineInput.payload,
-        epoch: "epoch-1",
-        entries: [makeTimelineEntry(5, "old"), makeTimelineEntry(7, "also old")],
-      },
-    });
-
-    // No new items appended (all dropped as stale)
-    expect(result.tail).toBe(baseTimelineInput.currentTail);
-    expect(result.cursorChanged).toBe(false);
-  });
-
-  it("drops entries with epoch mismatch", () => {
-    const existingCursor: TimelineCursor = {
-      epoch: "epoch-1",
-      startSeq: 1,
-      endSeq: 5,
-    };
-
-    const result = processTimelineResponse({
-      ...baseTimelineInput,
-      currentCursor: existingCursor,
-      payload: {
-        ...baseTimelineInput.payload,
-        epoch: "epoch-2",
-        entries: [makeTimelineEntry(6, "different epoch")],
-      },
-    });
-
-    expect(result.tail).toBe(baseTimelineInput.currentTail);
-    expect(result.cursorChanged).toBe(false);
-  });
-
-  it("resolves init when deferred matches direction", () => {
-    const result = processTimelineResponse({
-      ...baseTimelineInput,
-      isInitializing: true,
-      hasActiveInitDeferred: true,
-      initRequestDirection: "after",
-      payload: {
-        ...baseTimelineInput.payload,
-        direction: "after",
-        entries: [],
-      },
-    });
-
-    expect(result.initResolution).toBe("resolve");
-    expect(result.clearInitializing).toBe(true);
-  });
-
-  it("does not resolve init when directions differ (before vs after)", () => {
-    const result = processTimelineResponse({
-      ...baseTimelineInput,
-      isInitializing: true,
-      hasActiveInitDeferred: true,
-      initRequestDirection: "after",
+      currentTail,
+      currentCursor,
      payload: {
        ...baseTimelineInput.payload,
        direction: "before",
-        entries: [],
+        startSeq: 1,
+        endSeq: 2,
+        entries: [
+          makeTimelineEntry(1, "hello", "user_message"),
+          makeTimelineEntry(2, "older"),
+        ],
      },
    });

-    // "before" direction doesn't match "after" initRequestDirection,
-    // and "before" is not a bootstrap tail path, so init should NOT resolve
-    expect(result.initResolution).toBe(null);
-    expect(result.clearInitializing).toBe(false);
+    expect(result.cursorChanged).toBe(true);
+    expect(result.cursor).toEqual({
+      startSeq: 1,
+      endSeq: 4,
+    });
+    expect(result.tail).toHaveLength(3);
+    expect(result.tail[0]?.kind).toBe("user_message");
+    expect(result.tail[1]?.kind).toBe("assistant_message");
+    expect(result.tail[2]).toBe(currentTail[0]);
  });

-  it("clears initializing even without deferred", () => {
+  it("replaces stale provisional assistant UI when fetch-after returns committed row 121", () => {
+    const currentHead: StreamItem[] = [
+      {
+        kind: "assistant_message",
+        id: "head-assistant",
+        text: "partial",
+        timestamp: new Date(120000),
+      },
+    ];
+    const currentCursor: TimelineCursor = { startSeq: 1, endSeq: 120 };
+
    const result = processTimelineResponse({
      ...baseTimelineInput,
-      isInitializing: true,
-      hasActiveInitDeferred: false,
+      currentHead,
+      currentCursor,
      payload: {
        ...baseTimelineInput.payload,
        direction: "after",
-        entries: [],
-      },
-    });
-
-    expect(result.clearInitializing).toBe(true);
-    expect(result.initResolution).toBe(null);
-  });
-
-  it("always includes flush_pending_updates side effect on success", () => {
-    const result = processTimelineResponse({
-      ...baseTimelineInput,
-      payload: {
-        ...baseTimelineInput.payload,
-        entries: [],
-      },
-    });
-
-    expect(result.sideEffects.some((e) => e.type === "flush_pending_updates")).toBe(true);
-  });
-
-  it("initializes cursor when no existing cursor on first entries", () => {
-    const result = processTimelineResponse({
-      ...baseTimelineInput,
-      currentCursor: undefined,
-      payload: {
-        ...baseTimelineInput.payload,
-        epoch: "epoch-1",
-        entries: [makeTimelineEntry(1, "first"), makeTimelineEntry(2, "second")],
+        startSeq: 121,
+        endSeq: 121,
+        entries: [makeTimelineEntry(121, "finalized reply")],
      },
    });

+    expect(result.head).toEqual([]);
    expect(result.cursorChanged).toBe(true);
    expect(result.cursor).toEqual({
-      epoch: "epoch-1",
      startSeq: 1,
-      endSeq: 2,
+      endSeq: 121,
+    });
+    expect(result.tail[result.tail.length - 1]).toMatchObject({
+      kind: "assistant_message",
+      text: "finalized reply",
+    });
+  });
+
+  it("keeps provisional head when reconnect catch-up has no new committed rows yet", () => {
+    const currentHead: StreamItem[] = [
+      {
+        kind: "assistant_message",
+        id: "head-assistant",
+        text: "still streaming",
+        timestamp: new Date(120000),
+      },
+    ];
+    const currentCursor: TimelineCursor = { startSeq: 1, endSeq: 120 };
+
+    const result = processTimelineResponse({
+      ...baseTimelineInput,
+      currentHead,
+      currentCursor,
+      payload: {
+        ...baseTimelineInput.payload,
+        direction: "after",
+        startSeq: null,
+        endSeq: null,
+        entries: [],
+      },
+    });
+
+    expect(result.head).toBe(currentHead);
+    expect(result.cursorChanged).toBe(false);
+    expect(result.tail).toBe(baseTimelineInput.currentTail);
+  });
+
+  it("requests catch-up when committed rows arrive with a forward gap", () => {
+    const currentCursor: TimelineCursor = { startSeq: 1, endSeq: 120 };
+
+    const result = processTimelineResponse({
+      ...baseTimelineInput,
+      currentCursor,
+      payload: {
+        ...baseTimelineInput.payload,
+        direction: "after",
+        startSeq: 125,
+        endSeq: 125,
+        entries: [makeTimelineEntry(125, "far ahead")],
+      },
+    });
+
+    expect(result.cursorChanged).toBe(false);
+    expect(result.tail).toBe(baseTimelineInput.currentTail);
+    expect(result.sideEffects).toContainEqual({
+      type: "catch_up",
+      cursor: { endSeq: 120 },
    });
  });
 });

-// ---------------------------------------------------------------------------
-// processAgentStreamEvent
-// ---------------------------------------------------------------------------
-
 describe("processAgentStreamEvent", () => {
-  it("passes through non-timeline events without cursor changes", () => {
-    const turnEvent: AgentStreamEventPayload = {
-      type: "turn_completed",
-      provider: "claude",
-    };
-
+  it("treats seq-less timeline events as provisional head updates", () => {
    const result = processAgentStreamEvent({
      ...baseStreamInput,
-      event: turnEvent,
+      event: makeTimelineEvent("partial"),
      seq: undefined,
-      epoch: undefined,
    });

+    expect(result.changedHead).toBe(true);
+    expect(result.changedTail).toBe(false);
+    expect(result.head).toHaveLength(1);
+    expect(result.head[0]).toMatchObject({
+      kind: "assistant_message",
+      text: "partial",
+    });
    expect(result.cursorChanged).toBe(false);
-    expect(result.cursor).toBe(null);
-    expect(result.sideEffects).toEqual([]);
  });

-  it("accepts timeline event with cursor advance", () => {
-    const existingCursor: TimelineCursor = {
-      epoch: "epoch-1",
-      startSeq: 1,
-      endSeq: 4,
-    };
+  it("appends committed live rows to tail and clears superseded provisional assistant state", () => {
+    const currentHead: StreamItem[] = [
+      {
+        kind: "assistant_message",
+        id: "head-assistant",
+        text: "partial",
+        timestamp: new Date(1000),
+      },
+    ];
+    const currentCursor: TimelineCursor = { startSeq: 1, endSeq: 120 };

    const result = processAgentStreamEvent({
      ...baseStreamInput,
-      event: makeTimelineEvent("new chunk"),
-      seq: 5,
-      epoch: "epoch-1",
-      currentCursor: existingCursor,
+      event: makeTimelineEvent("finalized reply"),
+      seq: 121,
+      currentHead,
+      currentCursor,
    });

+    expect(result.changedTail).toBe(true);
+    expect(result.changedHead).toBe(true);
+    expect(result.head).toEqual([]);
    expect(result.cursorChanged).toBe(true);
    expect(result.cursor).toEqual({
-      epoch: "epoch-1",
      startSeq: 1,
-      endSeq: 5,
+      endSeq: 121,
+    });
+    expect(result.tail[result.tail.length - 1]).toMatchObject({
+      kind: "assistant_message",
+      text: "finalized reply",
    });
-    expect(result.sideEffects).toEqual([]);
  });

-  it("detects gap and emits catch-up side effect", () => {
-    const existingCursor: TimelineCursor = {
-      epoch: "epoch-1",
-      startSeq: 1,
-      endSeq: 4,
-    };
+  it("replaces provisional tool progress when the committed tool row arrives", () => {
+    const provisional = processAgentStreamEvent({
+      ...baseStreamInput,
+      event: makeToolCallEvent("running"),
+      seq: undefined,
+    });

+    const committed = processAgentStreamEvent({
+      ...baseStreamInput,
+      event: makeToolCallEvent("completed"),
+      seq: 8,
+      currentHead: provisional.head,
+      currentTail: provisional.tail,
+      currentCursor: { startSeq: 1, endSeq: 7 },
+    });
+
+    expect(committed.head).toEqual([]);
+    expect(committed.tail).toHaveLength(1);
+    expect(committed.tail[0]).toMatchObject({
+      kind: "tool_call",
+      payload: {
+        source: "agent",
+        data: {
+          callId: "call-1",
+          status: "completed",
+        },
+      },
+    });
+  });
+
+  it("requests catch-up when a committed live row skips ahead", () => {
    const result = processAgentStreamEvent({
      ...baseStreamInput,
      event: makeTimelineEvent("far ahead"),
-      seq: 10,
-      epoch: "epoch-1",
-      currentCursor: existingCursor,
+      seq: 125,
+      currentCursor: { startSeq: 1, endSeq: 120 },
    });

-    expect(result.cursorChanged).toBe(false);
    expect(result.changedTail).toBe(false);
    expect(result.changedHead).toBe(false);
-
-    const catchUp = result.sideEffects.find((e) => e.type === "catch_up");
-    expect(catchUp).toBeDefined();
-    expect(catchUp!.cursor).toEqual({
-      epoch: "epoch-1",
-      endSeq: 4,
-    });
-  });
-
-  it("drops stale timeline event", () => {
-    const existingCursor: TimelineCursor = {
-      epoch: "epoch-1",
-      startSeq: 1,
-      endSeq: 8,
-    };
-
-    const result = processAgentStreamEvent({
-      ...baseStreamInput,
-      event: makeTimelineEvent("old"),
-      seq: 5,
-      epoch: "epoch-1",
-      currentCursor: existingCursor,
-    });
-
    expect(result.cursorChanged).toBe(false);
+    expect(result.sideEffects).toContainEqual({
+      type: "catch_up",
+      cursor: { endSeq: 120 },
+    });
+  });
+
+  it("clears provisional head on terminal turn events without committing it to tail", () => {
+    const result = processAgentStreamEvent({
+      ...baseStreamInput,
+      event: {
+        type: "turn_completed",
+        provider: "claude",
+      },
+      currentHead: [
+        {
+          kind: "thought",
+          id: "reasoning-1",
+          text: "thinking",
+          timestamp: new Date(1000),
+          status: "loading",
+        },
+      ],
+    });
+
+    expect(result.changedHead).toBe(true);
    expect(result.changedTail).toBe(false);
-    expect(result.changedHead).toBe(false);
-    expect(result.sideEffects).toEqual([]);
-  });
-
-  it("drops timeline event with epoch mismatch", () => {
-    const existingCursor: TimelineCursor = {
-      epoch: "epoch-1",
-      startSeq: 1,
-      endSeq: 5,
-    };
-
-    const result = processAgentStreamEvent({
-      ...baseStreamInput,
-      event: makeTimelineEvent("wrong epoch"),
-      seq: 6,
-      epoch: "epoch-2",
-      currentCursor: existingCursor,
-    });
-
-    expect(result.cursorChanged).toBe(false);
-    expect(result.changedTail).toBe(false);
-    expect(result.changedHead).toBe(false);
-    expect(result.sideEffects).toEqual([]);
-  });
-
-  it("initializes cursor when none exists", () => {
-    const result = processAgentStreamEvent({
-      ...baseStreamInput,
-      event: makeTimelineEvent("first"),
-      seq: 1,
-      epoch: "epoch-1",
-      currentCursor: undefined,
-    });
-
-    expect(result.cursorChanged).toBe(true);
-    expect(result.cursor).toEqual({
-      epoch: "epoch-1",
-      startSeq: 1,
-      endSeq: 1,
-    });
-  });
-
-  it("derives optimistic idle status on turn_completed for running agent", () => {
-    const turnCompletedEvent: AgentStreamEventPayload = {
-      type: "turn_completed",
-      provider: "claude",
-    };
-
-    const result = processAgentStreamEvent({
-      ...baseStreamInput,
-      event: turnCompletedEvent,
-      currentAgent: {
-        status: "running",
-        updatedAt: new Date(1000),
-        lastActivityAt: new Date(1000),
-      },
-      timestamp: new Date(2000),
-    });
-
-    expect(result.agentChanged).toBe(true);
-    expect(result.agent).not.toBe(null);
-    expect(result.agent!.status).toBe("idle");
-    expect(result.agent!.updatedAt.getTime()).toBe(2000);
-    expect(result.agent!.lastActivityAt.getTime()).toBe(2000);
-  });
-
-  it("derives optimistic error status on turn_failed for running agent", () => {
-    const turnFailedEvent: AgentStreamEventPayload = {
-      type: "turn_failed",
-      provider: "claude",
-      error: "something broke",
-    };
-
-    const result = processAgentStreamEvent({
-      ...baseStreamInput,
-      event: turnFailedEvent,
-      currentAgent: {
-        status: "running",
-        updatedAt: new Date(1000),
-        lastActivityAt: new Date(1000),
-      },
-      timestamp: new Date(2000),
-    });
-
-    expect(result.agentChanged).toBe(true);
-    expect(result.agent!.status).toBe("error");
-  });
-
-  it("does not change agent when status is not running", () => {
-    const turnCompletedEvent: AgentStreamEventPayload = {
-      type: "turn_completed",
-      provider: "claude",
-    };
-
-    const result = processAgentStreamEvent({
-      ...baseStreamInput,
-      event: turnCompletedEvent,
-      currentAgent: {
-        status: "idle",
-        updatedAt: new Date(1000),
-        lastActivityAt: new Date(1000),
-      },
-      timestamp: new Date(2000),
-    });
-
-    expect(result.agentChanged).toBe(false);
-    expect(result.agent).toBe(null);
-  });
-
-  it("does not change agent when no agent is provided", () => {
-    const turnCompletedEvent: AgentStreamEventPayload = {
-      type: "turn_completed",
-      provider: "claude",
-    };
-
-    const result = processAgentStreamEvent({
-      ...baseStreamInput,
-      event: turnCompletedEvent,
-      currentAgent: null,
-      timestamp: new Date(2000),
-    });
-
-    expect(result.agentChanged).toBe(false);
-    expect(result.agent).toBe(null);
-  });
-
-  it("preserves updatedAt when agent timestamp is newer than event", () => {
-    const turnCompletedEvent: AgentStreamEventPayload = {
-      type: "turn_completed",
-      provider: "claude",
-    };
-
-    const result = processAgentStreamEvent({
-      ...baseStreamInput,
-      event: turnCompletedEvent,
-      currentAgent: {
-        status: "running",
-        updatedAt: new Date(5000),
-        lastActivityAt: new Date(5000),
-      },
-      timestamp: new Date(2000),
-    });
-
-    expect(result.agentChanged).toBe(true);
-    expect(result.agent!.updatedAt.getTime()).toBe(5000);
-    expect(result.agent!.lastActivityAt.getTime()).toBe(5000);
-  });
-
-  it("does not produce agent patch for non-terminal events", () => {
-    const result = processAgentStreamEvent({
-      ...baseStreamInput,
-      event: makeTimelineEvent("just text"),
-      currentAgent: {
-        status: "running",
-        updatedAt: new Date(1000),
-        lastActivityAt: new Date(1000),
-      },
-      seq: 1,
-      epoch: "epoch-1",
-      timestamp: new Date(2000),
-    });
-
-    expect(result.agentChanged).toBe(false);
-    expect(result.agent).toBe(null);
+    expect(result.head).toEqual([]);
+    expect(result.tail).toEqual([]);
  });
 });
@@ -1,7 +1,7 @@
 import type { AgentStreamEventPayload } from "@server/shared/messages";
 import type { AgentLifecycleStatus } from "@server/shared/agent-lifecycle";
 import type { StreamItem } from "@/types/stream";
-import { applyStreamEvent, hydrateStreamState, reduceStreamUpdate } from "@/types/stream";
+import { hydrateStreamState, reduceStreamUpdate } from "@/types/stream";
 import {
  classifySessionTimelineSeq,
  type SessionTimelineSeqDecision,
@@ -12,38 +12,25 @@ import {
 } from "@/contexts/session-timeline-bootstrap-policy";
 import { deriveOptimisticLifecycleStatus } from "@/contexts/session-stream-lifecycle";

-// ---------------------------------------------------------------------------
-// Shared cursor type
-// ---------------------------------------------------------------------------
-
 export type TimelineCursor = {
-  epoch: string;
  startSeq: number;
  endSeq: number;
 };

-// ---------------------------------------------------------------------------
-// Side-effect discriminated unions
-// ---------------------------------------------------------------------------
-
 export type TimelineReducerSideEffect =
-  | { type: "catch_up"; cursor: { epoch: string; endSeq: number } }
+  | { type: "catch_up"; cursor: { endSeq: number } }
  | { type: "flush_pending_updates" };

 export type AgentStreamReducerSideEffect = {
  type: "catch_up";
-  cursor: { epoch: string; endSeq: number };
+  cursor: { endSeq: number };
 };

-// ---------------------------------------------------------------------------
-// processTimelineResponse
-// ---------------------------------------------------------------------------
-
 type TimelineDirection = "tail" | "before" | "after";
 type InitRequestDirection = "tail" | "after";

 type TimelineResponseEntry = {
-  seqStart: number;
+  seq: number;
  provider: string;
  item: Record<string, unknown>;
  timestamp: string;
@@ -53,10 +40,8 @@ export interface ProcessTimelineResponseInput {
  payload: {
    agentId: string;
    direction: TimelineDirection;
-    reset: boolean;
-    epoch: string;
-    startCursor: { seq: number } | null;
-    endCursor: { seq: number } | null;
+    startSeq: number | null;
+    endSeq: number | null;
    entries: TimelineResponseEntry[];
    error: string | null;
  };
@@ -79,205 +64,9 @@ export interface ProcessTimelineResponseOutput {
  sideEffects: TimelineReducerSideEffect[];
 }

-export function processTimelineResponse(
-  input: ProcessTimelineResponseInput,
-): ProcessTimelineResponseOutput {
-  const {
-    payload,
-    currentTail,
-    currentHead,
-    currentCursor,
-    isInitializing,
-    hasActiveInitDeferred,
-    initRequestDirection,
-  } = input;
-
-  // ------------------------------------------------------------------
-  // Error path: reject init and leave stream state unchanged
-  // ------------------------------------------------------------------
-  if (payload.error) {
-    return {
-      tail: currentTail,
-      head: currentHead,
-      cursor: currentCursor,
-      cursorChanged: false,
-      initResolution: hasActiveInitDeferred ? "reject" : null,
-      clearInitializing: isInitializing,
-      error: payload.error,
-      sideEffects: [],
-    };
-  }
-
-  // ------------------------------------------------------------------
-  // Convert entries to timeline units
-  // ------------------------------------------------------------------
-  const timelineUnits = payload.entries.map((entry) => ({
-    seq: entry.seqStart,
-    event: {
-      type: "timeline",
-      provider: entry.provider,
-      item: entry.item,
-    } as AgentStreamEventPayload,
-    timestamp: new Date(entry.timestamp),
-  }));
-
-  const toHydratedEvents = (
-    units: typeof timelineUnits,
-  ): Array<{ event: AgentStreamEventPayload; timestamp: Date }> =>
-    units.map(({ event, timestamp }) => ({ event, timestamp }));
-
-  // ------------------------------------------------------------------
-  // Derive bootstrap policy (replace vs incremental)
-  // ------------------------------------------------------------------
-  const bootstrapPolicy = deriveBootstrapTailTimelinePolicy({
-    direction: payload.direction,
-    reset: payload.reset,
-    epoch: payload.epoch,
-    endCursor: payload.endCursor,
-    isInitializing,
-    hasActiveInitDeferred,
-  });
-  const replace = bootstrapPolicy.replace;
-
-  let nextTail = currentTail;
-  let nextHead = currentHead;
-  let nextCursor: TimelineCursor | null | undefined = currentCursor;
-  let cursorChanged = false;
-  const sideEffects: TimelineReducerSideEffect[] = [];
-
-  if (replace) {
-    // ----------------------------------------------------------------
-    // Replace path: full hydration from scratch
-    // ----------------------------------------------------------------
-    nextTail = hydrateStreamState(toHydratedEvents(timelineUnits), {
-      source: "canonical",
-    });
-    nextHead = [];
-
-    if (payload.startCursor && payload.endCursor) {
-      nextCursor = {
-        epoch: payload.epoch,
-        startSeq: payload.startCursor.seq,
-        endSeq: payload.endCursor.seq,
-      };
-      cursorChanged = true;
-    } else {
-      nextCursor = null;
-      cursorChanged = true;
-    }
-
-    if (bootstrapPolicy.catchUpCursor) {
-      sideEffects.push({
-        type: "catch_up",
-        cursor: bootstrapPolicy.catchUpCursor,
-      });
-    }
-  } else if (timelineUnits.length > 0) {
-    // ----------------------------------------------------------------
-    // Incremental append path
-    // ----------------------------------------------------------------
-    const acceptedUnits: typeof timelineUnits = [];
-    let cursor = currentCursor;
-    let gapCursor: { epoch: string; endSeq: number } | null = null;
-
-    for (const unit of timelineUnits) {
-      const decision: SessionTimelineSeqDecision = classifySessionTimelineSeq({
-        cursor: cursor ? { epoch: cursor.epoch, endSeq: cursor.endSeq } : null,
-        epoch: payload.epoch,
-        seq: unit.seq,
-      });
-
-      if (decision === "gap") {
-        gapCursor = cursor ? { epoch: cursor.epoch, endSeq: cursor.endSeq } : null;
-        break;
-      }
-      if (decision === "drop_stale" || decision === "drop_epoch") {
-        continue;
-      }
-
-      acceptedUnits.push(unit);
-      if (decision === "init") {
-        cursor = {
-          epoch: payload.epoch,
-          startSeq: unit.seq,
-          endSeq: unit.seq,
-        };
-        continue;
-      }
-      if (!cursor) {
-        continue;
-      }
-      cursor = {
-        ...cursor,
-        endSeq: unit.seq,
-      };
-    }
-
-    if (acceptedUnits.length > 0) {
-      nextTail = acceptedUnits.reduce<StreamItem[]>(
-        (state, { event, timestamp }) =>
-          reduceStreamUpdate(state, event, timestamp, {
-            source: "canonical",
-          }),
-        currentTail,
-      );
-    }
-
-    if (
-      cursor &&
-      (!currentCursor ||
-        currentCursor.epoch !== cursor.epoch ||
-        currentCursor.startSeq !== cursor.startSeq ||
-        currentCursor.endSeq !== cursor.endSeq)
-    ) {
-      nextCursor = cursor;
-      cursorChanged = true;
-    }
-
-    if (gapCursor) {
-      sideEffects.push({ type: "catch_up", cursor: gapCursor });
-    }
-  }
-
-  // ------------------------------------------------------------------
-  // Flush pending agent updates side effect
-  // ------------------------------------------------------------------
-  sideEffects.push({ type: "flush_pending_updates" });
-
-  // ------------------------------------------------------------------
-  // Init resolution
-  // ------------------------------------------------------------------
-  const shouldResolveDeferredInit = shouldResolveTimelineInit({
-    hasActiveInitDeferred,
-    isInitializing,
-    initRequestDirection,
-    responseDirection: payload.direction,
-    reset: payload.reset,
-  });
-  const clearInitializing = shouldResolveDeferredInit || (isInitializing && !hasActiveInitDeferred);
-
-  const initResolution: "resolve" | "reject" | null = shouldResolveDeferredInit ? "resolve" : null;
-
-  return {
-    tail: nextTail,
-    head: nextHead,
-    cursor: nextCursor,
-    cursorChanged,
-    initResolution,
-    clearInitializing,
-    error: null,
-    sideEffects,
-  };
-}
-
-// ---------------------------------------------------------------------------
-// processAgentStreamEvent
-// ---------------------------------------------------------------------------
-
 export interface ProcessAgentStreamEventInput {
  event: AgentStreamEventPayload;
  seq: number | undefined;
-  epoch: string | undefined;
  currentTail: StreamItem[];
  currentHead: StreamItem[];
  currentCursor: TimelineCursor | undefined;
@@ -307,75 +96,250 @@ export interface ProcessAgentStreamEventOutput {
  sideEffects: AgentStreamReducerSideEffect[];
 }

+function cursorsEqual(
+  left: TimelineCursor | null | undefined,
+  right: TimelineCursor | null | undefined,
+): boolean {
+  if (!left || !right) {
+    return left === right;
+  }
+  return left.startSeq === right.startSeq && left.endSeq === right.endSeq;
+}
+
+function removeSupersededProvisionalItems(
+  head: StreamItem[],
+  event: AgentStreamEventPayload,
+): StreamItem[] {
+  if (head.length === 0 || event.type !== "timeline") {
+    return head;
+  }
+
+  let nextHead = head;
+  if (event.item.type === "assistant_message") {
+    nextHead = head.filter((item) => item.kind !== "assistant_message");
+  } else if (event.item.type === "tool_call") {
+    const committedToolCall = event.item;
+    nextHead = head.filter(
+      (item) =>
+        item.kind !== "tool_call" ||
+        item.payload.source !== "agent" ||
+        item.payload.data.callId !== committedToolCall.callId,
+    );
+  }
+
+  return nextHead.length === head.length ? head : nextHead;
+}
+
+export function processTimelineResponse(
+  input: ProcessTimelineResponseInput,
+): ProcessTimelineResponseOutput {
+  const {
+    payload,
+    currentTail,
+    currentHead,
+    currentCursor,
+    isInitializing,
+    hasActiveInitDeferred,
+    initRequestDirection,
+  } = input;
+
+  if (payload.error) {
+    return {
+      tail: currentTail,
+      head: currentHead,
+      cursor: currentCursor,
+      cursorChanged: false,
+      initResolution: hasActiveInitDeferred ? "reject" : null,
+      clearInitializing: isInitializing,
+      error: payload.error,
+      sideEffects: [],
+    };
+  }
+
+  const timelineUnits = payload.entries.map((entry) => ({
+    seq: entry.seq,
+    event: {
+      type: "timeline",
+      provider: entry.provider,
+      item: entry.item,
+    } as AgentStreamEventPayload,
+    timestamp: new Date(entry.timestamp),
+  }));
+
+  const bootstrapPolicy = deriveBootstrapTailTimelinePolicy({
+    direction: payload.direction,
+    endSeq: payload.endSeq,
+    isInitializing,
+    hasActiveInitDeferred,
+  });
+
+  let nextTail = currentTail;
+  let nextHead = currentHead;
+  let nextCursor: TimelineCursor | null | undefined = currentCursor;
+  let cursorChanged = false;
+  const sideEffects: TimelineReducerSideEffect[] = [];
+
+  if (bootstrapPolicy.replace) {
+    nextTail = hydrateStreamState(
+      timelineUnits.map(({ event, timestamp }) => ({ event, timestamp })),
+      { source: "canonical" },
+    );
+    nextHead = [];
+    nextCursor =
+      typeof payload.startSeq === "number" && typeof payload.endSeq === "number"
+        ? {
+            startSeq: payload.startSeq,
+            endSeq: payload.endSeq,
+          }
+        : null;
+    cursorChanged = !cursorsEqual(currentCursor, nextCursor);
+
+    if (bootstrapPolicy.catchUpCursor) {
+      sideEffects.push({
+        type: "catch_up",
+        cursor: bootstrapPolicy.catchUpCursor,
+      });
+    }
+  } else if (payload.direction === "before") {
+    const prepended = hydrateStreamState(
+      timelineUnits.map(({ event, timestamp }) => ({ event, timestamp })),
+      { source: "canonical" },
+    );
+    nextTail = prepended.length > 0 ? [...prepended, ...currentTail] : currentTail;
+    const derivedCursor =
+      typeof payload.startSeq === "number"
+        ? {
+            startSeq: payload.startSeq,
+            endSeq: currentCursor?.endSeq ?? payload.endSeq ?? payload.startSeq,
+          }
+        : currentCursor;
+    nextCursor = derivedCursor;
+    cursorChanged = !cursorsEqual(currentCursor, derivedCursor);
+  } else if (timelineUnits.length > 0) {
+    const acceptedUnits: typeof timelineUnits = [];
+    let cursor = currentCursor;
+    let gapCursor: { endSeq: number } | null = null;
+
+    for (const unit of timelineUnits) {
+      const decision: SessionTimelineSeqDecision = classifySessionTimelineSeq({
+        cursor: cursor ? { endSeq: cursor.endSeq } : null,
+        seq: unit.seq,
+      });
+
+      if (decision === "gap") {
+        gapCursor = cursor ? { endSeq: cursor.endSeq } : null;
+        break;
+      }
+      if (decision === "drop_stale") {
+        continue;
+      }
+
+      acceptedUnits.push(unit);
+      cursor =
+        decision === "init"
+          ? { startSeq: unit.seq, endSeq: unit.seq }
+          : { ...(cursor ?? { startSeq: unit.seq, endSeq: unit.seq }), endSeq: unit.seq };
+      nextHead = removeSupersededProvisionalItems(nextHead, unit.event);
+    }
+
+    if (acceptedUnits.length > 0) {
+      nextTail = acceptedUnits.reduce<StreamItem[]>(
+        (state, { event, timestamp }) =>
+          reduceStreamUpdate(state, event, timestamp, {
+            source: "canonical",
+          }),
+        currentTail,
+      );
+    }
+
+    if (cursor && !cursorsEqual(currentCursor, cursor)) {
+      nextCursor = cursor;
+      cursorChanged = true;
+    }
+
+    if (gapCursor) {
+      sideEffects.push({ type: "catch_up", cursor: gapCursor });
+    }
+  }
+
+  sideEffects.push({ type: "flush_pending_updates" });
+
+  const shouldResolveDeferredInit = shouldResolveTimelineInit({
+    hasActiveInitDeferred,
+    isInitializing,
+    initRequestDirection,
+    responseDirection: payload.direction,
+  });
+  const clearInitializing = shouldResolveDeferredInit || (isInitializing && !hasActiveInitDeferred);
+
+  return {
+    tail: nextTail,
+    head: nextHead,
+    cursor: nextCursor,
+    cursorChanged,
+    initResolution: shouldResolveDeferredInit ? "resolve" : null,
+    clearInitializing,
+    error: null,
+    sideEffects,
+  };
+}
+
 export function processAgentStreamEvent(
  input: ProcessAgentStreamEventInput,
 ): ProcessAgentStreamEventOutput {
-  const { event, seq, epoch, currentTail, currentHead, currentCursor, currentAgent, timestamp } =
-    input;
+  const { event, seq, currentTail, currentHead, currentCursor, currentAgent, timestamp } = input;

-  let shouldApplyStreamEvent = true;
+  let nextTail = currentTail;
+  let nextHead = currentHead;
+  let changedTail = false;
+  let changedHead = false;
  let nextTimelineCursor: TimelineCursor | null = null;
  let cursorChanged = false;
  const sideEffects: AgentStreamReducerSideEffect[] = [];

-  // ------------------------------------------------------------------
-  // Timeline sequencing gate
-  // ------------------------------------------------------------------
-  if (event.type === "timeline" && typeof seq === "number" && typeof epoch === "string") {
+  if (event.type === "timeline" && typeof seq === "number") {
    const decision = classifySessionTimelineSeq({
-      cursor: currentCursor ? { epoch: currentCursor.epoch, endSeq: currentCursor.endSeq } : null,
-      epoch,
+      cursor: currentCursor ? { endSeq: currentCursor.endSeq } : null,
      seq,
    });

-    if (decision === "init") {
-      nextTimelineCursor = { epoch, startSeq: seq, endSeq: seq };
-      cursorChanged = true;
-    } else if (decision === "accept") {
-      nextTimelineCursor = {
-        ...(currentCursor ?? { epoch, startSeq: seq, endSeq: seq }),
-        epoch,
-        endSeq: seq,
-      };
-      cursorChanged = true;
-    } else if (decision === "gap") {
-      shouldApplyStreamEvent = false;
+    if (decision === "gap") {
      if (currentCursor) {
        sideEffects.push({
          type: "catch_up",
-          cursor: {
-            epoch: currentCursor.epoch,
-            endSeq: currentCursor.endSeq,
-          },
+          cursor: { endSeq: currentCursor.endSeq },
        });
      }
-    } else {
-      // drop_stale or drop_epoch
-      shouldApplyStreamEvent = false;
+    } else if (decision !== "drop_stale") {
+      nextTail = reduceStreamUpdate(currentTail, event, timestamp, {
+        source: "canonical",
+      });
+      changedTail = nextTail !== currentTail;
+
+      nextHead = removeSupersededProvisionalItems(currentHead, event);
+      changedHead = nextHead !== currentHead;
+
+      nextTimelineCursor =
+        decision === "init"
+          ? { startSeq: seq, endSeq: seq }
+          : { ...(currentCursor ?? { startSeq: seq, endSeq: seq }), endSeq: seq };
+      cursorChanged = !cursorsEqual(currentCursor, nextTimelineCursor);
    }
+  } else if (event.type === "timeline") {
+    nextHead = reduceStreamUpdate(currentHead, event, timestamp, {
+      source: "live",
+    });
+    changedHead = nextHead !== currentHead;
+  } else if (
+    (event.type === "turn_completed" ||
+      event.type === "turn_canceled" ||
+      event.type === "turn_failed") &&
+    currentHead.length > 0
+  ) {
+    nextHead = [];
+    changedHead = true;
  }

-  // ------------------------------------------------------------------
-  // Apply stream event to tail/head
-  // ------------------------------------------------------------------
-  const { tail, head, changedTail, changedHead } = shouldApplyStreamEvent
-    ? applyStreamEvent({
-        tail: currentTail,
-        head: currentHead,
-        event,
-        timestamp,
-        source: "live",
-      })
-    : {
-        tail: currentTail,
-        head: currentHead,
-        changedTail: false,
-        changedHead: false,
-      };
-
-  // ------------------------------------------------------------------
-  // Optimistic lifecycle status
-  // ------------------------------------------------------------------
  let agentPatch: AgentPatch | null = null;
  let agentChanged = false;

@@ -402,8 +366,8 @@ export function processAgentStreamEvent(
  }

  return {
-    tail,
-    head,
+    tail: nextTail,
+    head: nextHead,
    changedTail,
    changedHead,
    cursor: nextTimelineCursor,
@@ -2,26 +2,42 @@ import { describe, expect, it } from "vitest";
 import { classifySessionTimelineSeq } from "./session-timeline-seq-gate";
 import {
  deriveBootstrapTailTimelinePolicy,
+  deriveInitialTimelineRequest,
  shouldResolveTimelineInit,
 } from "./session-timeline-bootstrap-policy";

-describe("deriveBootstrapTailTimelinePolicy", () => {
-  it("always replaces on explicit reset without catch-up cursor", () => {
-    const policy = deriveBootstrapTailTimelinePolicy({
-      direction: "after",
-      reset: true,
-      epoch: "epoch-1",
-      endCursor: { seq: 200 },
-      isInitializing: false,
-      hasActiveInitDeferred: false,
+describe("deriveInitialTimelineRequest", () => {
+  it("uses tail bootstrap when history has not synced yet", () => {
+    expect(
+      deriveInitialTimelineRequest({
+        cursor: { seq: 42 },
+        hasAuthoritativeHistory: false,
+        initialTimelineLimit: 200,
+      }),
+    ).toEqual({
+      direction: "tail",
+      limit: 200,
    });
-
-    expect(policy.replace).toBe(true);
-    expect(policy.catchUpCursor).toBeNull();
  });

+  it("uses catch-up after the committed cursor once history is synced", () => {
+    expect(
+      deriveInitialTimelineRequest({
+        cursor: { seq: 42 },
+        hasAuthoritativeHistory: true,
+        initialTimelineLimit: 200,
+      }),
+    ).toEqual({
+      direction: "after",
+      cursor: { seq: 42 },
+      limit: 0,
+    });
+  });
+});
+
+describe("deriveBootstrapTailTimelinePolicy", () => {
  it("forces baseline replace and canonical catch-up for init tail race", () => {
-    const advancedCursor = { epoch: "epoch-1", endSeq: 205 };
+    const advancedCursor = { endSeq: 205 };
    const tailSeqStart = 101;
    const tailSeqEnd = 200;

@@ -29,7 +45,6 @@ describe("deriveBootstrapTailTimelinePolicy", () => {
    for (let seq = tailSeqStart; seq <= tailSeqEnd; seq += 1) {
      const decision = classifySessionTimelineSeq({
        cursor: advancedCursor,
-        epoch: "epoch-1",
        seq,
      });
      if (decision === "accept" || decision === "init") {
@@ -40,16 +55,13 @@ describe("deriveBootstrapTailTimelinePolicy", () => {

    const policy = deriveBootstrapTailTimelinePolicy({
      direction: "tail",
-      reset: false,
-      epoch: "epoch-1",
-      endCursor: { seq: 200 },
+      endSeq: 200,
      isInitializing: true,
      hasActiveInitDeferred: true,
    });

    expect(policy.replace).toBe(true);
    expect(policy.catchUpCursor).toEqual({
-      epoch: "epoch-1",
      endSeq: 200,
    });
  });
@@ -57,9 +69,7 @@ describe("deriveBootstrapTailTimelinePolicy", () => {
  it("does not replace non-bootstrap, non-reset responses", () => {
    const policy = deriveBootstrapTailTimelinePolicy({
      direction: "tail",
-      reset: false,
-      epoch: "epoch-1",
-      endCursor: { seq: 200 },
+      endSeq: 200,
      isInitializing: false,
      hasActiveInitDeferred: false,
    });
@@ -77,7 +87,6 @@ describe("shouldResolveTimelineInit", () => {
        isInitializing: true,
        initRequestDirection: "tail",
        responseDirection: "tail",
-        reset: false,
      }),
    ).toBe(true);
  });
@@ -89,7 +98,6 @@ describe("shouldResolveTimelineInit", () => {
        isInitializing: true,
        initRequestDirection: "tail",
        responseDirection: "after",
-        reset: false,
      }),
    ).toBe(false);
  });
@@ -101,7 +109,6 @@ describe("shouldResolveTimelineInit", () => {
        isInitializing: true,
        initRequestDirection: "after",
        responseDirection: "after",
-        reset: false,
      }),
    ).toBe(true);
  });
@@ -6,7 +6,6 @@ type BootstrapTailCursor = {
 } | null;

 type InitialTimelineCursor = {
-  epoch: string;
  seq: number;
 } | null;

@@ -20,48 +19,37 @@ export function deriveInitialTimelineRequest({
  initialTimelineLimit: number;
 }): {
  direction: "tail" | "after";
-  cursor?: { epoch: string; seq: number };
+  cursor?: { seq: number };
  limit: number;
-  projection: "canonical";
 } {
  if (!hasAuthoritativeHistory || !cursor) {
    return {
      direction: "tail",
      limit: initialTimelineLimit,
-      projection: "canonical",
    };
  }

  return {
    direction: "after",
-    cursor: { epoch: cursor.epoch, seq: cursor.seq },
+    cursor: { seq: cursor.seq },
    limit: 0,
-    projection: "canonical",
  };
 }

 export function deriveBootstrapTailTimelinePolicy({
  direction,
-  reset,
-  epoch,
-  endCursor,
+  endSeq,
  isInitializing,
  hasActiveInitDeferred,
 }: {
  direction: TimelineDirection;
-  reset: boolean;
-  epoch: string;
-  endCursor: BootstrapTailCursor;
+  endSeq: number | null;
  isInitializing: boolean;
  hasActiveInitDeferred: boolean;
 }): {
  replace: boolean;
-  catchUpCursor: { epoch: string; endSeq: number } | null;
+  catchUpCursor: { endSeq: number } | null;
 } {
-  if (reset) {
-    return { replace: true, catchUpCursor: null };
-  }
-
  const isBootstrapTailInit = direction === "tail" && isInitializing && hasActiveInitDeferred;
  if (!isBootstrapTailInit) {
    return { replace: false, catchUpCursor: null };
@@ -69,7 +57,7 @@ export function deriveBootstrapTailTimelinePolicy({

  return {
    replace: true,
-    catchUpCursor: endCursor ? { epoch, endSeq: endCursor.seq } : null,
+    catchUpCursor: typeof endSeq === "number" ? { endSeq } : null,
  };
 }

@@ -78,19 +66,14 @@ export function shouldResolveTimelineInit({
  isInitializing,
  initRequestDirection,
  responseDirection,
-  reset,
 }: {
  hasActiveInitDeferred: boolean;
  isInitializing: boolean;
  initRequestDirection: InitRequestDirection;
  responseDirection: TimelineDirection;
-  reset: boolean;
 }): boolean {
  if (!hasActiveInitDeferred || !isInitializing) {
    return false;
  }
-  if (reset) {
-    return true;
-  }
  return responseDirection === initRequestDirection;
 }
@@ -5,8 +5,7 @@ describe("classifySessionTimelineSeq", () => {
  it("accepts contiguous forward seq", () => {
    expect(
      classifySessionTimelineSeq({
-        cursor: { epoch: "epoch-1", endSeq: 4 },
-        epoch: "epoch-1",
+        cursor: { endSeq: 4 },
        seq: 5,
      }),
    ).toBe("accept");
@@ -15,8 +14,7 @@ describe("classifySessionTimelineSeq", () => {
  it("drops stale seq older than the current end", () => {
    expect(
      classifySessionTimelineSeq({
-        cursor: { epoch: "epoch-1", endSeq: 8 },
-        epoch: "epoch-1",
+        cursor: { endSeq: 8 },
        seq: 7,
      }),
    ).toBe("drop_stale");
@@ -25,28 +23,16 @@ describe("classifySessionTimelineSeq", () => {
  it("drops duplicate replay seq equal to the current end", () => {
    expect(
      classifySessionTimelineSeq({
-        cursor: { epoch: "epoch-1", endSeq: 8 },
-        epoch: "epoch-1",
+        cursor: { endSeq: 8 },
        seq: 8,
      }),
    ).toBe("drop_stale");
  });

-  it("drops epoch mismatch", () => {
-    expect(
-      classifySessionTimelineSeq({
-        cursor: { epoch: "epoch-1", endSeq: 4 },
-        epoch: "epoch-2",
-        seq: 5,
-      }),
-    ).toBe("drop_epoch");
-  });
-
  it("initializes when cursor is null", () => {
    expect(
      classifySessionTimelineSeq({
        cursor: null,
-        epoch: "epoch-1",
        seq: 1,
      }),
    ).toBe("init");
@@ -55,8 +41,7 @@ describe("classifySessionTimelineSeq", () => {
  it("classifies forward gaps", () => {
    expect(
      classifySessionTimelineSeq({
-        cursor: { epoch: "epoch-1", endSeq: 4 },
-        epoch: "epoch-1",
+        cursor: { endSeq: 4 },
        seq: 9,
      }),
    ).toBe("gap");
@@ -1,28 +1,22 @@
 export type SessionTimelineSeqCursor =
  | {
-      epoch: string;
      endSeq: number;
    }
  | null
  | undefined;

-export type SessionTimelineSeqDecision = "accept" | "drop_stale" | "drop_epoch" | "gap" | "init";
+export type SessionTimelineSeqDecision = "accept" | "drop_stale" | "gap" | "init";

 export function classifySessionTimelineSeq({
  cursor,
-  epoch,
  seq,
 }: {
  cursor: SessionTimelineSeqCursor;
-  epoch: string;
  seq: number;
 }): SessionTimelineSeqDecision {
  if (!cursor) {
    return "init";
  }
-  if (cursor.epoch !== epoch) {
-    return "drop_epoch";
-  }
  if (seq <= cursor.endSeq) {
    return "drop_stale";
  }
@@ -2,11 +2,10 @@ import { describe, expect, it } from "vitest";
 import { __private__ } from "./use-agent-initialization";

 describe("useAgentInitialization timeline request policy", () => {
-  it("uses canonical tail bootstrap when history has not synced yet", () => {
+  it("uses committed tail bootstrap when history has not synced yet", () => {
    expect(
      __private__.deriveInitialTimelineRequest({
        cursor: {
-          epoch: "epoch-1",
          seq: 42,
        },
        hasAuthoritativeHistory: false,
@@ -15,11 +14,10 @@ describe("useAgentInitialization timeline request policy", () => {
    ).toEqual({
      direction: "tail",
      limit: 200,
-      projection: "canonical",
    });
  });

-  it("uses canonical tail bootstrap when cursor is missing", () => {
+  it("uses committed tail bootstrap when cursor is missing", () => {
    expect(
      __private__.deriveInitialTimelineRequest({
        cursor: null,
@@ -29,15 +27,13 @@ describe("useAgentInitialization timeline request policy", () => {
    ).toEqual({
      direction: "tail",
      limit: 200,
-      projection: "canonical",
    });
  });

-  it("uses canonical catch-up after the current cursor once history is synced", () => {
+  it("uses committed catch-up after the current cursor once history is synced", () => {
    expect(
      __private__.deriveInitialTimelineRequest({
        cursor: {
-          epoch: "epoch-1",
          seq: 42,
        },
        hasAuthoritativeHistory: true,
@@ -45,9 +41,8 @@ describe("useAgentInitialization timeline request policy", () => {
      }),
    ).toEqual({
      direction: "after",
-      cursor: { epoch: "epoch-1", seq: 42 },
+      cursor: { seq: 42 },
      limit: 0,
-      projection: "canonical",
    });
  });

@@ -61,7 +56,6 @@ describe("useAgentInitialization timeline request policy", () => {
    ).toEqual({
      direction: "tail",
      limit: 0,
-      projection: "canonical",
    });
  });

@@ -60,7 +60,7 @@ export function useAgentInitialization({
      const hasAuthoritativeHistory =
        session?.agentAuthoritativeHistoryApplied.get(agentId) === true;
      const timelineRequest = deriveInitialTimelineRequest({
-        cursor: cursor ? { epoch: cursor.epoch, seq: cursor.endSeq } : null,
+        cursor: cursor ? { seq: cursor.endSeq } : null,
        hasAuthoritativeHistory,
        initialTimelineLimit,
      });
@@ -107,7 +107,6 @@ export function useAgentInitialization({
        await client.fetchAgentTimeline(agentId, {
          direction: "tail",
          limit: initialTimelineLimit,
-          projection: "canonical",
        });
      } catch (error) {
        setAgentInitializing(agentId, false);
@@ -1137,7 +1137,7 @@ export class HostRuntimeStore {
    }
  }

-  async bootstrap(options?: { manageBuiltInDaemon?: boolean }): Promise<void> {
+  async bootstrap(): Promise<void> {
    if (this.bootstrapAttempted) {
      return;
    }
@@ -1153,9 +1153,7 @@ export class HostRuntimeStore {
    }

    if (shouldUseDesktopDaemon()) {
-      if (options?.manageBuiltInDaemon ?? true) {
-        await this.bootstrapDesktop();
-      }
+      await this.bootstrapDesktop();
    } else {
      await this.bootstrapLocalhost();
    }
@@ -1165,16 +1163,20 @@ export class HostRuntimeStore {
    try {
      const daemon = await startDesktopDaemon();
      const connection = connectionFromListen(daemon.listen);
-      if (!connection || !daemon.serverId) {
+      if (!connection) {
        return;
      }
+      const { client, serverId, hostname } = await connectToDaemon(connection, {
+        timeoutMs: DEFAULT_LOCALHOST_BOOTSTRAP_TIMEOUT_MS,
+      });
      await this.upsertHostConnection({
-        serverId: daemon.serverId,
-        label: daemon.hostname ?? undefined,
+        serverId,
+        label: hostname ?? daemon.hostname ?? undefined,
        connection,
+        existingClient: client,
      });
    } catch (error) {
-      console.warn("[HostRuntime] Failed to bootstrap desktop daemon", error);
+      console.warn("[HostRuntime] Failed to bootstrap desktop daemon connection", error);
    }
  }

@@ -7,6 +7,7 @@ import { PaseoLogo } from "@/components/icons/paseo-logo";
 import { SidebarMenuToggle } from "@/components/headers/menu-header";
 import { useOpenProjectPicker } from "@/hooks/use-open-project-picker";
 import { usePanelStore } from "@/stores/panel-store";
+import { getIsDesktopMac } from "@/constants/layout";
 import { useDesktopDragHandlers, useTrafficLightPadding } from "@/utils/desktop-window";

 export function OpenProjectScreen({ serverId }: { serverId: string }) {
@@ -18,10 +19,8 @@ export function OpenProjectScreen({ serverId }: { serverId: string }) {
  const openProjectPicker = useOpenProjectPicker(serverId);

  const isMobile = UnistylesRuntime.breakpoint === "xs" || UnistylesRuntime.breakpoint === "sm";
-  const collapsedSidebarInset =
-    !isMobile && !desktopAgentListOpen && trafficLightPadding.side
-      ? trafficLightPadding
-      : { left: 0, right: 0 };
+  const needsTrafficLightInset = !isMobile && !desktopAgentListOpen && getIsDesktopMac();
+  const trafficLightInset = needsTrafficLightInset ? trafficLightPadding.left : 0;
  const dragHandlers = useDesktopDragHandlers();

  useEffect(() => {
@@ -32,7 +31,7 @@ export function OpenProjectScreen({ serverId }: { serverId: string }) {

  return (
    <View style={styles.container} {...dragHandlers}>
-      <View style={[styles.menuToggle, { paddingTop: insets.top, paddingLeft: collapsedSidebarInset.left, paddingRight: collapsedSidebarInset.right }]}>
+      <View style={[styles.menuToggle, { paddingTop: insets.top, paddingLeft: trafficLightInset }]}>
        <SidebarMenuToggle />
      </View>
      <View style={styles.content}>
@@ -191,7 +191,6 @@ export type DaemonServerInfo = {
 };

 export interface AgentTimelineCursorState {
-  epoch: string;
  startSeq: number;
  endSeq: number;
 }
@@ -2,11 +2,8 @@ import { useEffect, useMemo, useRef, useState } from "react";
 import { Platform, type PointerEvent as RNPointerEvent, type ViewProps } from "react-native";
 import {
  getIsDesktopMac,
-  getIsDesktop,
  DESKTOP_TRAFFIC_LIGHT_WIDTH,
  DESKTOP_TRAFFIC_LIGHT_HEIGHT,
-  DESKTOP_WINDOW_CONTROLS_WIDTH,
-  DESKTOP_WINDOW_CONTROLS_HEIGHT,
 } from "@/constants/layout";
 import { getDesktopWindow } from "@/desktop/electron/window";
 import { isDesktop } from "@/desktop/host";
@@ -123,11 +120,11 @@ export function useDesktopDragHandlers(): DesktopDragViewProps {
  }, [isActive]);
 }

-export function useTrafficLightPadding(): { left: number; right: number; top: number; side: 'left' | 'right' | null } {
+export function useTrafficLightPadding(): { left: number; top: number } {
  const [isFullscreen, setIsFullscreen] = useState(false);

  useEffect(() => {
-    if (Platform.OS !== "web" || !getIsDesktop()) return;
+    if (Platform.OS !== "web" || !getIsDesktopMac()) return;

    let disposed = false;
    let cleanup: (() => void) | undefined;
@@ -178,23 +175,12 @@ export function useTrafficLightPadding(): { left: number; right: number; top: nu
    };
  }, []);

-  if (!getIsDesktop() || isFullscreen) {
-    return { left: 0, right: 0, top: 0, side: null };
-  }
-
-  if (getIsDesktopMac()) {
-    return {
-      left: DESKTOP_TRAFFIC_LIGHT_WIDTH,
-      right: 0,
-      top: DESKTOP_TRAFFIC_LIGHT_HEIGHT,
-      side: 'left',
-    };
+  if (!getIsDesktopMac() || isFullscreen) {
+    return { left: 0, top: 0 };
  }

  return {
-    left: 0,
-    right: DESKTOP_WINDOW_CONTROLS_WIDTH,
-    top: DESKTOP_WINDOW_CONTROLS_HEIGHT,
-    side: 'right',
+    left: DESKTOP_TRAFFIC_LIGHT_WIDTH,
+    top: DESKTOP_TRAFFIC_LIGHT_HEIGHT,
  };
 }
@@ -1,6 +1,6 @@
 {
  "name": "@getpaseo/cli",
-  "version": "0.1.37",
+  "version": "0.1.33",
  "description": "Paseo CLI - control your AI coding agents from the command line",
  "type": "module",
  "files": [
@@ -24,8 +24,8 @@
  },
  "dependencies": {
    "@clack/prompts": "^1.0.0",
-    "@getpaseo/relay": "0.1.37",
-    "@getpaseo/server": "0.1.37",
+    "@getpaseo/relay": "0.1.33",
+    "@getpaseo/server": "0.1.33",
    "chalk": "^5.3.0",
    "commander": "^12.0.0",
    "mime-types": "^2.1.35",
@@ -1,6 +1,5 @@
 import type { Command } from "commander";
 import { connectToDaemon, getDaemonHost } from "../../utils/client.js";
-import { isSameOrDescendantPath } from "../../utils/paths.js";

 export function addDeleteOptions(cmd: Command): Command {
  return cmd
@@ -70,9 +69,12 @@ export async function runDeleteCommand(
    if (options.all) {
      agents = agents.filter((a) => !a.archivedAt);
    } else if (options.cwd) {
+      const filterCwd = options.cwd;
      agents = agents.filter((a) => {
        if (a.archivedAt) return false;
-        return isSameOrDescendantPath(options.cwd!, a.cwd);
+        const agentCwd = a.cwd.replace(/\/$/, "");
+        const targetCwd = filterCwd.replace(/\/$/, "");
+        return agentCwd === targetCwd || agentCwd.startsWith(targetCwd + "/");
      });
    } else if (id) {
      const fetchResult = await client.fetchAgent(id);
@@ -3,7 +3,6 @@ import type { AgentSnapshotPayload } from "@getpaseo/server";
 import { connectToDaemon, getDaemonHost } from "../../utils/client.js";
 import type { CommandOptions, ListResult, OutputSchema, CommandError } from "../../output/index.js";
 import { collectMultiple } from "../../utils/command-options.js";
-import { isSameOrDescendantPath } from "../../utils/paths.js";

 export function addLsOptions(cmd: Command): Command {
  return cmd
@@ -194,7 +193,11 @@ export async function runLsCommand(

    // Optional cwd filter.
    if (options.cwd) {
-      agents = agents.filter((a) => isSameOrDescendantPath(options.cwd!, a.cwd));
+      const targetCwd = options.cwd.replace(/\/$/, "");
+      agents = agents.filter((a) => {
+        const agentCwd = a.cwd.replace(/\/$/, "");
+        return agentCwd === targetCwd || agentCwd.startsWith(targetCwd + "/");
+      });
    }

    // Apply label filtering only when explicitly requested.
@@ -193,7 +193,6 @@ export async function resolveStructuredResponseMessage(options: {
  try {
    const timeline = await options.client.fetchAgentTimeline(options.agentId, {
      direction: "tail",
-      projection: "projected",
      limit: 200,
    });
    for (let index = timeline.entries.length - 1; index >= 0; index -= 1) {
@@ -1,6 +1,5 @@
 import { Command } from "commander";
 import { connectToDaemon, getDaemonHost } from "../../utils/client.js";
-import { isSameOrDescendantPath } from "../../utils/paths.js";
 import type {
  CommandOptions,
  SingleResult,
@@ -76,9 +75,12 @@ export async function runStopCommand(
      agents = agents.filter((a) => !a.archivedAt);
    } else if (options.cwd) {
      // Stop agents in directory
+      const filterCwd = options.cwd;
      agents = agents.filter((a) => {
        if (a.archivedAt) return false;
-        return isSameOrDescendantPath(options.cwd!, a.cwd);
+        const agentCwd = a.cwd.replace(/\/$/, "");
+        const targetCwd = filterCwd.replace(/\/$/, "");
+        return agentCwd === targetCwd || agentCwd.startsWith(targetCwd + "/");
      });
    } else if (id) {
      // Stop specific agent
@@ -294,8 +294,7 @@ export function resolveTcpHostFromListen(listen: string): string | null {
    normalized.startsWith("/") ||
    normalized.startsWith("unix://") ||
    normalized.startsWith("pipe://") ||
-    normalized.startsWith("\\\\.\\pipe\\") ||
-    /^[A-Za-z]:[/\\]/.test(normalized)
+    normalized.startsWith("\\\\.\\pipe\\")
  ) {
    return null;
  }
@@ -1,5 +1,4 @@
 import { spawnSync } from "node:child_process";
-import { platform } from "node:os";

 export interface NodePathFromPidResult {
  nodePath: string | null;
@@ -13,14 +12,17 @@ function normalizeError(error: unknown): string {
  return String(error);
 }

-function resolveNodePathFromPidUnix(pid: number): NodePathFromPidResult {
+export function resolveNodePathFromPid(pid: number): NodePathFromPidResult {
  const result = spawnSync("ps", ["-o", "comm=", "-p", String(pid)], {
    encoding: "utf8",
    stdio: ["ignore", "pipe", "pipe"],
  });

  if (result.error) {
-    return { nodePath: null, error: `ps failed: ${normalizeError(result.error)}` };
+    return {
+      nodePath: null,
+      error: `ps failed: ${normalizeError(result.error)}`,
+    };
  }

  if ((result.status ?? 1) !== 0) {
@@ -32,36 +34,12 @@ function resolveNodePathFromPidUnix(pid: number): NodePathFromPidResult {
  }

  const resolved = result.stdout.trim();
-  return resolved ? { nodePath: resolved } : { nodePath: null, error: "ps returned an empty command path" };
-}
-
-function resolveNodePathFromPidWindows(pid: number): NodePathFromPidResult {
-  const result = spawnSync(
-    "wmic",
-    ["process", "where", `ProcessId=${pid}`, "get", "ExecutablePath", "/VALUE"],
-    { encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] },
-  );
-
-  if (result.error) {
-    return { nodePath: null, error: `wmic failed: ${normalizeError(result.error)}` };
-  }
-
-  if ((result.status ?? 1) !== 0) {
-    const details = result.stderr?.trim();
+  if (!resolved) {
    return {
      nodePath: null,
-      error: details ? `wmic failed: ${details}` : `wmic exited with code ${result.status ?? 1}`,
+      error: "ps returned an empty command path",
    };
  }

-  // wmic output format: "ExecutablePath=C:\path\to\node.exe\r\n"
-  const match = result.stdout.match(/ExecutablePath=(.+)/);
-  const resolved = match?.[1]?.trim();
-  return resolved ? { nodePath: resolved } : { nodePath: null, error: "wmic returned no executable path" };
-}
-
-export function resolveNodePathFromPid(pid: number): NodePathFromPidResult {
-  return platform() === "win32"
-    ? resolveNodePathFromPidWindows(pid)
-    : resolveNodePathFromPidUnix(pid);
+  return { nodePath: resolved };
 }
@@ -1,4 +1,3 @@
-import path from "path";
 import type { Command } from "commander";
 import { connectToDaemon, getDaemonHost } from "../../utils/client.js";
 import type {
@@ -78,7 +77,7 @@ export async function runArchiveCommand(

    // Find the worktree by name or branch
    const worktree = listResponse.worktrees.find((wt) => {
-      const name = path.basename(wt.worktreePath);
+      const name = wt.worktreePath.split("/").pop();
      return name === nameArg || wt.branchName === nameArg;
    });

@@ -106,7 +105,7 @@ export async function runArchiveCommand(
      throw error;
    }

-    const worktreeName = path.basename(worktree.worktreePath) || nameArg;
+    const worktreeName = worktree.worktreePath.split("/").pop() ?? nameArg;

    return {
      type: "single",
@@ -45,15 +45,10 @@ export function normalizeDaemonHost(raw: string): string | null {
    return trimmed.startsWith("\\\\.\\pipe\\") ? `pipe://${trimmed}` : trimmed;
  }

-  if (trimmed.startsWith("/") || trimmed.startsWith("~")) {
+  if (path.isAbsolute(trimmed)) {
    return `unix://${trimmed}`;
  }

-  // Windows absolute paths (e.g. C:\Users\foo) are filesystem paths, not TCP or IPC targets.
-  if (/^[A-Za-z]:[/\\]/.test(trimmed)) {
-    return null;
-  }
-
  if (/^\d+$/.test(trimmed)) {
    return `127.0.0.1:${trimmed}`;
  }
@@ -1,27 +0,0 @@
-/**
- * Path utilities for cwd filtering in agent commands.
- */
-
-/**
- * Check if `candidatePath` is the same directory as `basePath` or a descendant of it.
- *
- * Handles both Unix (/) and Windows (\) path separators, including mixed separators.
- * This is important because agent cwd paths come from the agent's OS (could be Windows)
- * while the CLI filter path comes from the user (could also be Windows or Unix).
- */
-export function isSameOrDescendantPath(basePath: string, candidatePath: string): boolean {
-  // Normalize both paths: replace all backslashes with forward slashes, strip trailing separator
-  let normalizedBase = basePath.replace(/\\/g, "/").replace(/\/$/, "");
-  let normalizedCandidate = candidatePath.replace(/\\/g, "/").replace(/\/$/, "");
-
-  // Windows paths are case-insensitive — detect by drive letter prefix (e.g. "C:/")
-  if (/^[a-zA-Z]:\//.test(normalizedBase) || /^[a-zA-Z]:\//.test(normalizedCandidate)) {
-    normalizedBase = normalizedBase.toLowerCase();
-    normalizedCandidate = normalizedCandidate.toLowerCase();
-  }
-
-  return (
-    normalizedCandidate === normalizedBase ||
-    normalizedCandidate.startsWith(normalizedBase + "/")
-  );
-}
@@ -11,7 +11,6 @@ export async function fetchProjectedTimelineItems(
  const timeline = await input.client.fetchAgentTimeline(input.agentId, {
    direction: "tail",
    limit: 0,
-    projection: "projected",
  });
  return timeline.entries.map((entry) => entry.item);
 }
@@ -42,12 +42,4 @@ console.log("=== Local Daemon Utility Helpers ===\n");
  console.log("✓ rejects empty and non-host listen values\n");
 }

-{
-  console.log("Test 5: rejects Windows absolute paths (not TCP endpoints)");
-  assert.strictEqual(resolveTcpHostFromListen("C:\\Users\\foo\\.paseo\\paseo.sock"), null);
-  assert.strictEqual(resolveTcpHostFromListen("D:\\project\\socket"), null);
-  assert.strictEqual(resolveTcpHostFromListen("C:\\paseo.sock"), null);
-  console.log("✓ rejects Windows absolute paths\n");
-}
-
 console.log("=== All local daemon utility tests passed ===");
@@ -41,13 +41,6 @@ console.log("=== CLI IPC Target Helpers ===\n");
  console.log("✓ local unix socket paths normalize into IPC daemon targets\n");
 }

-{
-  console.log("Test 3b: Windows absolute paths are NOT treated as unix sockets");
-  assert.strictEqual(normalizeDaemonHost("C:\\Users\\foo\\.paseo\\paseo.sock"), null);
-  assert.strictEqual(normalizeDaemonHost("D:\\project\\socket"), null);
-  console.log("✓ Windows absolute paths are not treated as unix sockets\n");
-}
-
 {
  console.log("Test 4: default host resolution tries local IPC first, then localhost fallback");
  const paseoHome = mkdtempSync(path.join(os.tmpdir(), "paseo-client-targets-"));
@@ -1,213 +0,0 @@
-#!/usr/bin/env npx tsx
-
-/**
- * CWD Filter Path Tests
- *
- * Tests that cwd filtering in agent commands works correctly
- * with both Unix and Windows-style paths.
- *
- * Bug: The original code used hardcoded "/" separators for:
- *   1. Stripping trailing separators (only stripped "/", not "\")
- *   2. Descendant matching (appended "/" instead of platform separator)
- *
- * This causes Windows paths like "C:\Users\dev\project" to fail matching
- * against "C:\Users\dev\project\sub" because the code appends "/" instead
- * of "\" for the startsWith check.
- */
-
-import assert from "node:assert";
-import { isSameOrDescendantPath } from "../src/utils/paths.ts";
-
-console.log("=== CWD Filter Path Tests ===\n");
-
-// Test 1: Unix exact match
-{
-  console.log("Test 1: Unix exact match");
-  assert.strictEqual(
-    isSameOrDescendantPath("/home/user/project", "/home/user/project"),
-    true,
-    "exact Unix paths should match",
-  );
-  console.log("✓ Unix exact match\n");
-}
-
-// Test 2: Unix descendant match
-{
-  console.log("Test 2: Unix descendant match");
-  assert.strictEqual(
-    isSameOrDescendantPath("/home/user/project", "/home/user/project/src"),
-    true,
-    "Unix descendant should match",
-  );
-  console.log("✓ Unix descendant match\n");
-}
-
-// Test 3: Unix non-match (sibling)
-{
-  console.log("Test 3: Unix non-match (sibling)");
-  assert.strictEqual(
-    isSameOrDescendantPath("/home/user/project", "/home/user/other"),
-    false,
-    "sibling directories should not match",
-  );
-  console.log("✓ Unix non-match (sibling)\n");
-}
-
-// Test 4: Unix prefix overlap (project vs project2)
-{
-  console.log("Test 4: Unix prefix overlap (project vs project2)");
-  assert.strictEqual(
-    isSameOrDescendantPath("/home/user/project", "/home/user/project2"),
-    false,
-    "prefix overlap without separator should not match",
-  );
-  console.log("✓ Unix prefix overlap\n");
-}
-
-// Test 5: Unix trailing slash on base
-{
-  console.log("Test 5: Unix trailing slash on base");
-  assert.strictEqual(
-    isSameOrDescendantPath("/home/user/project/", "/home/user/project/src"),
-    true,
-    "trailing slash on base should still match descendants",
-  );
-  console.log("✓ Unix trailing slash on base\n");
-}
-
-// Test 6: Unix trailing slash on candidate
-{
-  console.log("Test 6: Unix trailing slash on candidate");
-  assert.strictEqual(
-    isSameOrDescendantPath("/home/user/project", "/home/user/project/"),
-    true,
-    "trailing slash on candidate should match as same dir",
-  );
-  console.log("✓ Unix trailing slash on candidate\n");
-}
-
-// Test 7: Windows exact match
-{
-  console.log("Test 7: Windows exact match");
-  assert.strictEqual(
-    isSameOrDescendantPath("C:\\Users\\dev\\project", "C:\\Users\\dev\\project"),
-    true,
-    "exact Windows paths should match",
-  );
-  console.log("✓ Windows exact match\n");
-}
-
-// Test 8: Windows descendant match
-{
-  console.log("Test 8: Windows descendant match");
-  assert.strictEqual(
-    isSameOrDescendantPath("C:\\Users\\dev\\project", "C:\\Users\\dev\\project\\src"),
-    true,
-    "Windows descendant should match",
-  );
-  console.log("✓ Windows descendant match\n");
-}
-
-// Test 9: Windows non-match (sibling)
-{
-  console.log("Test 9: Windows non-match (sibling)");
-  assert.strictEqual(
-    isSameOrDescendantPath("C:\\Users\\dev\\project", "C:\\Users\\dev\\other"),
-    false,
-    "Windows sibling directories should not match",
-  );
-  console.log("✓ Windows non-match (sibling)\n");
-}
-
-// Test 10: Windows prefix overlap (project vs project2)
-{
-  console.log("Test 10: Windows prefix overlap (project vs project2)");
-  assert.strictEqual(
-    isSameOrDescendantPath("C:\\Users\\dev\\project", "C:\\Users\\dev\\project2"),
-    false,
-    "Windows prefix overlap without separator should not match",
-  );
-  console.log("✓ Windows prefix overlap\n");
-}
-
-// Test 11: Windows trailing backslash on base
-{
-  console.log("Test 11: Windows trailing backslash on base");
-  assert.strictEqual(
-    isSameOrDescendantPath("C:\\Users\\dev\\project\\", "C:\\Users\\dev\\project\\src"),
-    true,
-    "trailing backslash on base should still match descendants",
-  );
-  console.log("✓ Windows trailing backslash on base\n");
-}
-
-// Test 12: Windows trailing backslash on candidate
-{
-  console.log("Test 12: Windows trailing backslash on candidate");
-  assert.strictEqual(
-    isSameOrDescendantPath("C:\\Users\\dev\\project", "C:\\Users\\dev\\project\\"),
-    true,
-    "trailing backslash on candidate should match as same dir",
-  );
-  console.log("✓ Windows trailing backslash on candidate\n");
-}
-
-// Test 13: Mixed separators (agent might use \ while CLI sends /)
-{
-  console.log("Test 13: Mixed separators");
-  assert.strictEqual(
-    isSameOrDescendantPath("C:/Users/dev/project", "C:\\Users\\dev\\project\\src"),
-    true,
-    "mixed separators should still match",
-  );
-  console.log("✓ Mixed separators\n");
-}
-
-// Test 14: Deep Windows descendant
-{
-  console.log("Test 14: Deep Windows descendant");
-  assert.strictEqual(
-    isSameOrDescendantPath(
-      "C:\\Users\\dev\\project",
-      "C:\\Users\\dev\\project\\src\\components\\Button.tsx",
-    ),
-    true,
-    "deep Windows descendant should match",
-  );
-  console.log("✓ Deep Windows descendant\n");
-}
-
-// Test 15: Case-insensitive Windows descendant match
-{
-  console.log("Test 15: Case-insensitive Windows descendant match");
-  assert.strictEqual(
-    isSameOrDescendantPath("C:\\Users\\Dev\\Project", "c:\\users\\dev\\project\\src"),
-    true,
-    "Windows paths with different casing should match (case-insensitive)",
-  );
-  console.log("✓ Case-insensitive Windows descendant match\n");
-}
-
-// Test 16: Case-insensitive Windows exact match
-{
-  console.log("Test 16: Case-insensitive Windows exact match");
-  assert.strictEqual(
-    isSameOrDescendantPath("c:\\repo", "C:\\Repo"),
-    true,
-    "Windows paths with different casing should match exactly (case-insensitive)",
-  );
-  console.log("✓ Case-insensitive Windows exact match\n");
-}
-
-// Test 17: Parent should not match
-{
-  console.log("Test 15: Parent should not match");
-  assert.strictEqual(
-    isSameOrDescendantPath("/home/user/project/src", "/home/user/project"),
-    false,
-    "parent directory should not match (only same-or-descendant)",
-  );
-  console.log("✓ Parent should not match\n");
-}
-
-console.log("=== All CWD filter path tests passed ===");
@@ -9,6 +9,5 @@ if not exist "%APP_EXECUTABLE%" (
  exit /b 1
 )

-set "ELECTRON_RUN_AS_NODE=1"
-"%APP_EXECUTABLE%" "%RESOURCES_DIR%\app.asar\dist\daemon\node-entrypoint-runner.js" bare "%RESOURCES_DIR%\app.asar\node_modules\@getpaseo\cli\dist\index.js" %*
-exit /b %errorlevel%
+set "PASEO_DESKTOP_CLI=1"
+"%APP_EXECUTABLE%" %*
@@ -14,7 +14,6 @@ publish:
  owner: getpaseo
  repo: paseo
 mac:
-  artifactName: "Paseo-${version}-${arch}.${ext}"
  category: public.app-category.developer-tools
  icon: assets/icon.icns
  hardenedRuntime: true
@@ -31,15 +30,11 @@ linux:
  category: Development
  icon: assets
  artifactName: "Paseo-${version}-${arch}.${ext}"
-  maintainer: "Mohamed Boudra <hello@moboudra.com>"
-  vendor: "Paseo"
  extraResources:
    - from: bin/paseo
      to: bin/paseo
  target:
    - AppImage
-    - deb
-    - rpm
    - tar.gz
 win:
  icon: assets/icon.ico
@@ -1,6 +1,6 @@
 {
  "name": "@getpaseo/desktop",
-  "version": "0.1.37",
+  "version": "0.1.33",
  "private": true,
  "description": "Paseo desktop app (Electron wrapper)",
  "main": "dist/main.js",
@@ -12,9 +12,8 @@
    "typecheck": "tsc --noEmit -p tsconfig.json"
  },
  "dependencies": {
-    "@getpaseo/cli": "0.1.37",
-    "@getpaseo/server": "0.1.37",
-    "electron-log": "^5.4.3",
+    "@getpaseo/cli": "0.1.33",
+    "@getpaseo/server": "0.1.33",
    "electron-updater": "^6.6.2",
    "ws": "^8.14.2"
  },
@@ -26,15 +25,5 @@
    "typescript": "5.9.3",
    "unzip-crx-3": "^0.2.0",
    "wait-on": "8.0.5"
-  },
-  "homepage": "https://paseo.sh",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/getpaseo/paseo.git"
-  },
-  "author": {
-    "name": "Mohamed Boudra",
-    "email": "hello@moboudra.com"
-  },
-  "license": "AGPL-3.0-or-later"
+  }
 }
@@ -189,8 +189,7 @@ function resolveTcpHostFromListen(listen: string): string | null {
    normalized.startsWith("/") ||
    normalized.startsWith("unix://") ||
    normalized.startsWith("pipe://") ||
-    normalized.startsWith("\\\\.\\pipe\\") ||
-    /^[A-Za-z]:[/\\]/.test(normalized)
+    normalized.startsWith("\\\\.\\pipe\\")
  ) {
    return null;
  }
@@ -545,6 +544,12 @@ export function createDaemonCommandHandlers(): Record<string, DesktopCommandHand
      return downloadAndInstallUpdate(currentVersion);
    },
    get_local_daemon_version: () => getLocalDaemonVersion(),
+    webview_log: (args) => {
+      const level = typeof args?.level === "number" ? args.level : 1;
+      const message = typeof args?.message === "string" ? args.message : "";
+      const method = level === 0 ? "debug" : level === 2 ? "warn" : level >= 3 ? "error" : "info";
+      console[method]("[webview]", message);
+    },
  };
 }

@@ -1,6 +1,3 @@
-import log from "electron-log/main";
-log.initialize();
-
 import path from "node:path";
 import { pathToFileURL } from "node:url";
 import { existsSync } from "node:fs";
@@ -92,17 +89,8 @@ async function createMainWindow(): Promise<void> {
    height: 800,
    show: false,
    ...(iconPath ? { icon: iconPath } : {}),
-    titleBarStyle: "hidden",
-    ...(isMac
-      ? { trafficLightPosition: { x: 16, y: 14 } }
-      : {
-          titleBarOverlay: {
-            color: "#18181c",
-            symbolColor: "#e4e4e7",
-            height: 48,
-          },
-          autoHideMenuBar: true,
-        }),
+    titleBarStyle: isMac ? "hidden" : "default",
+    trafficLightPosition: isMac ? { x: 16, y: 14 } : undefined,
    webPreferences: {
      preload: getPreloadPath(),
      contextIsolation: true,
@@ -1,4 +1,3 @@
-import "electron-log/preload";
 import { contextBridge, ipcRenderer } from "electron";

 type EventHandler = (payload: unknown) => void;
@@ -1,6 +1,6 @@
 {
  "name": "@getpaseo/expo-two-way-audio",
-  "version": "0.1.37",
+  "version": "0.1.33",
  "description": "Native module for two way audio streaming",
  "main": "build/index.js",
  "types": "build/index.d.ts",
@@ -1,6 +1,6 @@
 {
  "name": "@getpaseo/highlight",
-  "version": "0.1.37",
+  "version": "0.1.33",
  "type": "module",
  "publishConfig": {
    "access": "public"
@@ -1,6 +1,6 @@
 {
  "name": "@getpaseo/relay",
-  "version": "0.1.37",
+  "version": "0.1.33",
  "description": "Paseo relay for bridging daemon and client connections",
  "type": "module",
  "publishConfig": {
@@ -0,0 +1,339 @@
+# Voice Assistant System Prompt
+
+## 1. Core Voice Rules (NON-NEGOTIABLE)
+
+### Voice Context
+
+You are a **voice-controlled** assistant. The user speaks to you via phone and hears your responses via TTS.
+
+### Voice Message Envelope
+
+Some user utterances will be wrapped in an XML tag like:
+
+`<voice-transcription focused-agent-id="...">...</voice-transcription>`
+
+- Treat the inner text as what the user said (STT output).
+- `focused-agent-id` is **context only**: it means which agent screen the user is currently looking at. It does *not* mean all actions must target that agent, but it is a strong hint for ambiguous commands like “stop it” or “cancel the agent”.
+
+**Critical constraints:**
+
+- User typically codes from their **phone** using voice
+- **No visual feedback** - they can't see command output unless at laptop
+- Input comes through **speech-to-text (STT)** which makes errors
+- Output is spoken via **text-to-speech (TTS)**
+- User may be mobile, away from desk, multitasking
+
+### Communication Rules
+
+**1-3 sentences maximum per response. Always.**
+
+- **Plain speech only** - NO markdown (no bullets, bold, lists, headers)
+- **Progressive disclosure** - answer what's asked, let user ask for more
+- **Start high-level** - give the gist, not every detail
+- **Natural pauses** - leave room for user to respond or redirect
+
+**Good example:**
+
+```
+User: "List my agents"
+You: "You have two agents. One working on authentication in the web app, another running tests in Faro."
+
+User: "How's the auth agent doing?"
+You: "It finished adding the login flow and is waiting for your approval on the database migration."
+```
+
+**Bad example:**
+
+```
+User: "List my agents"
+You: "You have 2 agents: 1. **auth-agent** - Working on authentication 2. **test-agent** - Running tests..."
+```
+
+### Handling STT Errors
+
+Speech-to-text makes mistakes. Fix them silently using context.
+
+**Common errors:**
+
+- Homophones: "list" → "missed", "code" → "load"
+- Project names: "faro" → "pharaoh", "mcp" → "empty"
+- Technical terms: "typescript" → "type script", "npm install" → "NPM in style"
+
+**How to handle:**
+
+1. Use context to fix obvious mistakes silently
+2. Ask for clarification only when truly ambiguous
+3. Never lecture about the error - just handle it
+4. When clarifying, be brief: "Which project? Web, agent, or MCP?"
+
+**Examples:**
+
+- User: "Run empty install" → Interpret as "Run npm install"
+- User: "Check the agent" → If only one agent, check that one; if multiple, ask which
+
+### Immediate Silence Protocol
+
+If user says any of these, **STOP ALL OUTPUT IMMEDIATELY**:
+
+- "I'm not talking to you"
+- "Shut up" / "Be quiet" / "Stop talking"
+- "Not you"
+
+**Response: Complete silence. No acknowledgment. Wait for user to address you again.**
+
+## 2. Delegation Pattern
+
+### Core Rule: Always Work Through Coding Agents
+
+Direct command-line tools (`execute_command`, `send_text_to_command`, `kill_command`, etc.) are disabled. Every change to files, git, builds, or tests must go through a coding agent. Your job is to decide when to reuse an existing agent versus spinning up a new one, then route follow-ups appropriately.
+
+### Safe Operations (Execute Immediately)
+
+These orchestration tools only read or summarize state:
+
+- `list_agents()` – discover who exists before delegating
+- `get_agent_activity()` – pull the curated activity/readout for a specific agent
+- `wait_for_agent()` – block until an agent requests permission or completes the current run
+
+Call them without asking when context requires it. Never fabricate their output.
+
+### Delegated Operations (Announce + Execute)
+
+- `create_agent()` – Ask for confirmation unless the user already issued a clear imperative (“spin up a new planner”), then acknowledge and create immediately.
+- `send_agent_prompt()` – Route the user’s request to the focused agent. If the user explicitly names a different agent, switch focus first, then send the prompt.
+- `set_agent_mode()`, `cancel_agent()`, `kill_agent()` – Only when the user directs you to or the agent is stuck. Confirm destructive actions.
+
+After delegating, monitor via `wait_for_agent()` or `get_agent_activity()` and translate the relevant summary back to the user.
+
+### When to Ask vs Act
+
+Ask only when the routing decision is truly ambiguous. Otherwise:
+
+- Default to the most recently addressed agent.
+- If the user mentions a new agent (“spin up planner”, “Codex, pick this up”), treat it as both a creation/selection and a focus switch.
+- Use activity context to disambiguate references (“keep going on the migration” → whichever agent was migrating).
+
+### Tool Results Reporting
+
+After any agent-facing tool call, verbally report the key result in one sentence: who acted, what happened, and whether more work is pending. Example: “Agent Planner says the test plan is drafted and still running validations.” Progressive disclosure still applies—offer deeper details only when asked.
+
+## 4. Agent Integrations
+
+### Your Role: Orchestrator
+
+You orchestrate work. Agents execute.
+
+**First action when agent work is mentioned: Call `list_agents()`**
+
+Load the agent list before any agent interaction. Always.
+
+#### Focus Management
+
+- Keep a lightweight "focus" pointer to the last agent the user explicitly addressed or implicitly referenced. Route follow-up utterances there unless the user names another agent.
+- Update focus whenever the user spins up a new agent (“create a planner for this”) or targets one by name. Treat that change as sticky until silence/irrelevant turns cause confidence to drop.
+- When confidence is low (long gap, conflicting references), briefly confirm: “Do you want Planner or Architect on this?”
+- Always narrate hand-offs: “Okay, handing that to Planner.”
+- Every time you speak on behalf of an agent, prefix with `Agent <name> says …` so the user always knows who just responded and can redirect explicitly.
+
+**Confirm before destructive agent operations:**
+- Creating agents: "Create agent in [directory] for [task]?" (unless user already issued a direct imperative)
+- Killing agents: "Kill agent [id] working on [task]?"
+
+**Delegate vs execute:**
+- Everything touching code, git, or shell runs through agents
+- Keep lightweight questions or summaries in-orchestrator when no action is needed
+- Active agent context → Send prompt to that agent (respect focus)
+
+### Available Agents (Source of Truth)
+
+We only have two coding agents. Do not call tools to discover them—treat this section as canonical. When you create or configure an agent, runtime validation will reject invalid combinations.
+
+**Claude Code (`claude`)**
+- Default mode: `plan`
+- Alternate mode: `bypassPermissions`
+- Best for deliberative work. Start in `plan` when the user wants transparency, switch to `bypassPermissions` only with explicit approval for fast execution.
+
+**Codex (`codex`)**
+- Default mode: `auto`
+- Other modes: `read-only`, `full-access`
+- Use `read-only` for safe inspection, `auto` for normal edit/run loops, and escalate to `full-access` only when the user authorizes unrestricted access.
+
+### Creating Agents
+
+**Confirm creation only when intent is unclear.** If the user gives a direct imperative (“spin up a new planner agent in paseo”), acknowledge and create immediately; otherwise, ask.
+
+```javascript
+// Claude Code with planning
+create_agent({
+  cwd: "~/dev/paseo",
+  agentType: "claude",
+  initialPrompt: "add dark mode toggle to settings page",
+  initialMode: "plan"
+})
+
+// Codex for quick edits
+create_agent({
+  cwd: "~/dev/paseo",
+  agentType: "codex",
+  initialPrompt: "clean up the logging",
+  initialMode: "auto"
+})
+```
+
+If the user omits `initialMode`, the defaults above apply. Invalid agentType/mode pairs will throw—just surface the error.
+
+### Working with Agents
+
+**Send prompts to agents:**
+
+```javascript
+// Send task (non-blocking by default)
+send_agent_prompt({
+  agentId: "abc123",
+  prompt: "explain how authentication works"
+})
+// Returns immediately, agent processes in background
+
+// Send task and wait for completion
+send_agent_prompt({
+  agentId: "abc123",
+  prompt: "fix the bug in auth.ts",
+  maxWait: 60000  // Wait up to 60 seconds
+})
+
+// Change mode and send prompt (Claude -> bypassPermissions, Codex -> full-access)
+send_agent_prompt({
+  agentId: "abc123",
+  prompt: "implement user registration",
+  sessionMode: "bypassPermissions"
+})
+```
+
+**Check agent status:**
+
+```javascript
+// Get current status
+get_agent_status({ agentId: "abc123" })
+// Returns: { status: "processing", info: {...} }
+
+// Get agent activity (curated, human-readable)
+get_agent_activity({
+  agentId: "abc123",
+  format: "curated"  // Clean summary of what agent did
+})
+
+// List all agents
+list_agents()
+// Returns: { agents: [{id, status, createdAt, ...}, ...] }
+```
+
+**Control agents:**
+
+```javascript
+// Change session mode (safe, no confirmation needed)
+set_agent_mode({
+  agentId: "abc123",
+  modeId: "plan"
+})
+
+// Cancel current task (safe, no confirmation needed)
+cancel_agent({ agentId: "abc123" })
+
+// Kill agent (REQUIRES confirmation first)
+kill_agent({ agentId: "abc123" })
+```
+
+### Agent Workflow Pattern
+
+```javascript
+// 1. Load agents first
+list_agents()
+
+// 2. If creating new agent, confirm first
+// You: "Create agent in ~/dev/project for authentication?"
+// User: "yes"
+
+// 3. Create with type + mode
+create_agent({
+  cwd: "~/dev/project",
+  agentType: "claude",
+  initialPrompt: "add authentication",
+  initialMode: "plan"
+})
+
+// 4. Monitor or send follow-up tasks
+get_agent_activity({ agentId })
+send_agent_prompt({ agentId, prompt: "add tests" })
+```
+
+## 5. Git & GitHub
+
+### Git Worktree Utilities
+
+Custom utilities for safe worktree management:
+
+**create-worktree:**
+- Creates new git worktree with new branch
+- Example: `create-worktree "feature"` creates `~/dev/repo-feature`
+- Outputs WORKTREE_PATH for you to parse
+
+**delete-worktree:**
+- Preserves the branch, only deletes directory
+- Safe to use - won't lose work
+- Run from within worktree directory
+
+### GitHub CLI (gh)
+
+Already authenticated. Use for:
+
+- Creating PRs: `gh pr create`
+- Viewing PRs: `gh pr view`
+- Managing issues: `gh issue list`
+- Checking CI: `gh pr checks`
+
+## 6. Projects & Context
+
+### Project Locations
+
+All projects in `~/dev`:
+
+**paseo**
+- Location: `~/dev/paseo`
+- Packages: `voice-assistant`
+
+**Faro** (Autonomous Competitive Intelligence)
+- Bare repo: `~/dev/faro`
+- Main checkout: `~/dev/faro/main`
+
+**Blank.page** (Minimal browser text editor)
+- Location: `~/dev/blank.page/editor`
+
+### Decision Rules
+
+**Agent work mentioned?**
+1. Call `list_agents()` first
+2. Reuse existing agent if task relates to its work
+3. Only confirm new-agent creation when the request is ambiguous. Clear imperatives (“spin up a new planner agent”) should be acknowledged and executed immediately.
+
+**Creating/killing agents?**
+- Ask: "Create agent in [dir] for [task]?" when intent isn’t explicit
+- Ask: "Kill agent [id]?"
+- Wait for "yes"
+
+**Task routing:**
+- All coding tasks → Delegate to an agent
+- Active agent + related work → Delegate to that agent
+- If the user explicitly mentions another agent, switch focus before delegating
+
+**Context tracking:**
+- Track active agents and their directories
+- Use conversation context to resolve ambiguity
+- Fix STT errors silently
+- Maintain a recency-based focus pointer and narrate any focus change out loud
+
+### Core Reminders
+
+- Call actual tools, never just describe
+- 1-3 sentences max per response
+- Always report agent/tool results verbally (preface with "Agent X says …" when relaying)
+- Default to action when context is clear
@@ -0,0 +1,9 @@
+import { defineConfig } from "drizzle-kit";
+
+export default defineConfig({
+  schema: "./packages/server/src/server/db/schema.ts",
+  out: "./packages/server/src/server/db/migrations",
+  dialect: "postgresql",
+  strict: true,
+  verbose: true,
+});
@@ -1,6 +1,6 @@
 {
  "name": "@getpaseo/server",
-  "version": "0.1.37",
+  "version": "0.1.33",
  "description": "Paseo backend server",
  "type": "module",
  "publishConfig": {
@@ -13,7 +13,8 @@
    "dist/scripts",
    "src/server/speech/providers/local/sherpa/assets",
    "README.md",
-    ".env.example"
+    ".env.example",
+    "agent-prompt.md"
  ],
  "exports": {
    ".": {
@@ -45,6 +46,7 @@
    "speech:download": "tsx scripts/download-speech-models.ts",
    "speech:tts:matrix": "tsx scripts/generate-sherpa-tts-matrix.ts",
    "speech:transcribe:local": "tsx scripts/transcribe-local-wav.ts",
+    "db:query": "tsx scripts/db-query.ts",
    "test": "npm run test:unit && npm run test:integration",
    "test:unit": "vitest run --exclude \"**/*.e2e.test.ts\"",
    "test:integration": "vitest run --maxWorkers=1 --minWorkers=1 src/server/daemon-e2e/models.e2e.test.ts src/server/daemon-e2e/live-preferences.e2e.test.ts src/server/agent/model-catalog.e2e.test.ts",
@@ -63,8 +65,9 @@
    "@ai-sdk/openai": "2.0.52",
    "@anthropic-ai/claude-agent-sdk": "^0.2.11",
    "@deepgram/sdk": "^3.4.0",
-    "@getpaseo/highlight": "0.1.37",
-    "@getpaseo/relay": "0.1.37",
+    "@electric-sql/pglite": "^0.4.1",
+    "@getpaseo/highlight": "0.1.33",
+    "@getpaseo/relay": "0.1.33",
    "@modelcontextprotocol/sdk": "^1.20.1",
    "@opencode-ai/sdk": "1.2.6",
    "@sctg/sentencepiece-js": "^1.1.0",
@@ -72,6 +75,7 @@
    "ai": "5.0.78",
    "ajv": "^8.17.1",
    "dotenv": "^17.2.3",
+    "drizzle-orm": "^0.45.1",
    "express": "^4.18.2",
    "express-basic-auth": "^1.2.1",
    "fast-uri": "^3.1.0",
@@ -95,6 +99,7 @@
  },
  "devDependencies": {
    "@playwright/test": "^1.56.1",
+    "drizzle-kit": "^0.31.10",
    "@types/express": "^4.17.20",
    "@types/node": "^20.9.0",
    "@types/qrcode": "^1.5.6",
@@ -0,0 +1,98 @@
+#!/usr/bin/env npx tsx
+/**
+ * Run arbitrary SQL against the running Paseo daemon's PGlite database.
+ *
+ * Connects to the daemon's dev query endpoint (available in dev mode only).
+ *
+ * Usage:
+ *   npx tsx packages/server/scripts/db-query.ts "SELECT * FROM agent_snapshots"
+ *   npx tsx packages/server/scripts/db-query.ts --port 6767 "SELECT count(*) FROM agent_timeline_rows"
+ *
+ * Without args, shows table row counts.
+ */
+
+import path from "node:path";
+import os from "node:os";
+import fs from "node:fs";
+
+function findDaemonPort(explicit?: string): number {
+  if (explicit) return parseInt(explicit, 10);
+
+  // Check for running dev daemon config
+  const tmpDir = os.tmpdir();
+  for (const entry of fs.readdirSync(tmpDir)) {
+    if (entry.startsWith("paseo-dev.")) {
+      const configPath = path.join(tmpDir, entry, "config.json");
+      if (fs.existsSync(configPath)) {
+        try {
+          const config = JSON.parse(fs.readFileSync(configPath, "utf-8"));
+          const listen = config.daemon?.listen;
+          if (typeof listen === "string") {
+            const portMatch = listen.match(/:(\d+)$/);
+            if (portMatch) return parseInt(portMatch[1]!, 10);
+          }
+        } catch {}
+      }
+    }
+  }
+
+  return 6767;
+}
+
+async function main() {
+  const args = process.argv.slice(2);
+  let port: string | undefined;
+  const queries: string[] = [];
+
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === "--port" && args[i + 1]) {
+      port = args[++i];
+    } else {
+      queries.push(args[i]!);
+    }
+  }
+
+  if (queries.length === 0) {
+    queries.push(
+      "SELECT 'agent_snapshots' AS table_name, count(*)::int AS rows FROM agent_snapshots UNION ALL " +
+        "SELECT 'agent_timeline_rows', count(*)::int FROM agent_timeline_rows UNION ALL " +
+        "SELECT 'projects', count(*)::int FROM projects UNION ALL " +
+        "SELECT 'workspaces', count(*)::int FROM workspaces " +
+        "ORDER BY table_name",
+    );
+  }
+
+  const daemonPort = findDaemonPort(port);
+  const url = `http://localhost:${daemonPort}/dev/db-query`;
+
+  for (const sql of queries) {
+    try {
+      const res = await fetch(url, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ sql }),
+      });
+
+      if (!res.ok) {
+        const text = await res.text();
+        console.error(`HTTP ${res.status}: ${text}`);
+        continue;
+      }
+
+      const { rows } = await res.json();
+      if (rows.length === 0) {
+        console.log("(0 rows)\n");
+      } else {
+        console.table(rows);
+      }
+    } catch (err: any) {
+      if (err.cause?.code === "ECONNREFUSED") {
+        console.error(`Cannot connect to daemon at port ${daemonPort}. Is it running?`);
+        process.exit(1);
+      }
+      console.error(`Error: ${err.message}\n`);
+    }
+  }
+}
+
+main();
@@ -1704,24 +1704,15 @@ describe("DaemonClient", () => {
          agentId: "agent_cli",
          agent: null,
          direction: "tail",
-          projection: "projected",
-          epoch: "epoch-1",
-          reset: false,
-          staleCursor: false,
-          gap: false,
-          window: { minSeq: 1, maxSeq: 1, nextSeq: 2 },
-          startCursor: { epoch: "epoch-1", seq: 1 },
-          endCursor: { epoch: "epoch-1", seq: 1 },
+          startSeq: 1,
+          endSeq: 1,
          hasOlder: false,
          hasNewer: false,
          entries: [
            {
              timestamp: "2026-02-08T20:20:00.000Z",
              provider: "codex",
-              seqStart: 1,
-              seqEnd: 1,
-              sourceSeqRanges: [{ startSeq: 1, endSeq: 1 }],
-              collapsed: [],
+              seq: 1,
              item: {
                type: "tool_call",
                callId: "call_cli_snapshot",
@@ -1798,24 +1789,15 @@ describe("DaemonClient", () => {
          agentId: "agent_cli",
          agent: null,
          direction: "tail",
-          projection: "projected",
-          epoch: "epoch-1",
-          reset: false,
-          staleCursor: false,
-          gap: false,
-          window: { minSeq: 1, maxSeq: 1, nextSeq: 2 },
-          startCursor: { epoch: "epoch-1", seq: 1 },
-          endCursor: { epoch: "epoch-1", seq: 1 },
+          startSeq: 1,
+          endSeq: 1,
          hasOlder: false,
          hasNewer: false,
          entries: [
            {
              timestamp: "2026-02-08T20:20:00.000Z",
              provider: "codex",
-              seqStart: 1,
-              seqEnd: 1,
-              sourceSeqRanges: [{ startSeq: 1, endSeq: 1 }],
-              collapsed: [],
+              seq: 1,
              item: {
                type: "tool_call",
                callId: "call_cli_invalid",
@@ -130,7 +130,6 @@ export type DaemonEvent =
      event: AgentStreamEventPayload;
      timestamp: string;
      seq?: number;
-      epoch?: string;
    }
  | { type: "status"; payload: { status: string } & Record<string, unknown> }
  | { type: "agent_deleted"; agentId: string }
@@ -244,13 +243,13 @@ type KillTerminalPayload = KillTerminalResponse["payload"];
 export type FetchAgentTimelinePayload = FetchAgentTimelineResponseMessage["payload"];

 export type FetchAgentTimelineDirection = FetchAgentTimelinePayload["direction"];
-export type FetchAgentTimelineProjection = FetchAgentTimelinePayload["projection"];
-export type FetchAgentTimelineCursor = NonNullable<FetchAgentTimelinePayload["startCursor"]>;
+export type FetchAgentTimelineCursor = NonNullable<
+  Extract<SessionInboundMessage, { type: "fetch_agent_timeline_request" }>["cursor"]
+>;
 export type FetchAgentTimelineOptions = {
  direction?: FetchAgentTimelineDirection;
  cursor?: FetchAgentTimelineCursor;
  limit?: number;
-  projection?: FetchAgentTimelineProjection;
  requestId?: string;
 };

@@ -1396,7 +1395,6 @@ export class DaemonClient {
      ...(options.direction ? { direction: options.direction } : {}),
      ...(options.cursor ? { cursor: options.cursor } : {}),
      ...(typeof options.limit === "number" ? { limit: options.limit } : {}),
-      ...(options.projection ? { projection: options.projection } : {}),
    });

    const payload = await this.sendRequest({
@@ -3100,7 +3098,6 @@ export class DaemonClient {
          event: msg.payload.event,
          timestamp: msg.payload.timestamp,
          ...(typeof msg.payload.seq === "number" ? { seq: msg.payload.seq } : {}),
-          ...(typeof msg.payload.epoch === "string" ? { epoch: msg.payload.epoch } : {}),
        };
      case "status":
        return { type: "status", payload: msg.payload };
@@ -0,0 +1,128 @@
+import type pino from "pino";
+
+import type { ManagedAgent } from "./agent/agent-manager.js";
+import type { AgentManager } from "./agent/agent-manager.js";
+import type { AgentPersistenceHandle, AgentSessionConfig } from "./agent/agent-sdk-types.js";
+import type { AgentSnapshotStore } from "./agent/agent-snapshot-store.js";
+import {
+  buildConfigOverrides,
+  buildSessionConfig,
+  extractTimestamps,
+  toAgentPersistenceHandle,
+} from "./persistence-hooks.js";
+
+const pendingAgentBootstrapLoads = new Map<string, Promise<ManagedAgent>>();
+
+export type AgentLoadingServiceOptions = {
+  agentManager: Pick<
+    AgentManager,
+    | "createAgent"
+    | "getAgent"
+    | "reloadAgentSession"
+    | "resumeAgentFromPersistence"
+  >;
+  agentStorage: Pick<AgentSnapshotStore, "get">;
+  logger: pino.Logger;
+};
+
+// Coordinates cold loads, explicit resumes, and refreshes for persisted agents.
+export class AgentLoadingService {
+  private readonly agentManager: AgentLoadingServiceOptions["agentManager"];
+  private readonly agentStorage: AgentLoadingServiceOptions["agentStorage"];
+  private readonly logger: pino.Logger;
+
+  constructor(options: AgentLoadingServiceOptions) {
+    this.agentManager = options.agentManager;
+    this.agentStorage = options.agentStorage;
+    this.logger = options.logger.child({ component: "agent-loading" });
+  }
+
+  async ensureAgentLoaded(options: { agentId: string }): Promise<ManagedAgent> {
+    const existing = this.agentManager.getAgent(options.agentId);
+    if (existing) {
+      return existing;
+    }
+
+    const inflight = pendingAgentBootstrapLoads.get(options.agentId);
+    if (inflight) {
+      return inflight;
+    }
+
+    const initPromise = this.loadStoredAgent(options);
+    pendingAgentBootstrapLoads.set(options.agentId, initPromise);
+
+    try {
+      return await initPromise;
+    } finally {
+      const current = pendingAgentBootstrapLoads.get(options.agentId);
+      if (current === initPromise) {
+        pendingAgentBootstrapLoads.delete(options.agentId);
+      }
+    }
+  }
+
+  async resumeAgent(options: {
+    handle: AgentPersistenceHandle;
+    overrides?: Partial<AgentSessionConfig>;
+  }): Promise<ManagedAgent> {
+    return this.agentManager.resumeAgentFromPersistence(options.handle, options.overrides);
+  }
+
+  async refreshAgent(options: { agentId: string }): Promise<ManagedAgent> {
+    const existing = this.agentManager.getAgent(options.agentId);
+    if (existing) {
+      return existing.persistence
+        ? await this.agentManager.reloadAgentSession(options.agentId)
+        : existing;
+    }
+
+    const record = await this.agentStorage.get(options.agentId);
+    if (!record) {
+      throw new Error(`Agent not found: ${options.agentId}`);
+    }
+
+    const handle = toAgentPersistenceHandle(this.logger, record.persistence);
+    if (!handle) {
+      throw new Error(`Agent ${options.agentId} cannot be refreshed because it lacks persistence`);
+    }
+
+    return this.agentManager.resumeAgentFromPersistence(
+      handle,
+      buildConfigOverrides(record),
+      options.agentId,
+      extractTimestamps(record),
+    );
+  }
+
+  private async loadStoredAgent(options: { agentId: string }): Promise<ManagedAgent> {
+    const record = await this.agentStorage.get(options.agentId);
+    if (!record) {
+      throw new Error(`Agent not found: ${options.agentId}`);
+    }
+
+    const handle = toAgentPersistenceHandle(this.logger, record.persistence);
+    let snapshot: ManagedAgent;
+    if (handle) {
+      snapshot = await this.agentManager.resumeAgentFromPersistence(
+        handle,
+        buildConfigOverrides(record),
+        options.agentId,
+        extractTimestamps(record),
+      );
+      this.logger.info(
+        { agentId: options.agentId, provider: record.provider },
+        "Agent resumed from persistence",
+      );
+    } else {
+      snapshot = await this.agentManager.createAgent(buildSessionConfig(record), options.agentId, {
+        labels: record.labels,
+      });
+      this.logger.info(
+        { agentId: options.agentId, provider: record.provider },
+        "Agent created from stored config",
+      );
+    }
+
+    return this.agentManager.getAgent(options.agentId) ?? snapshot;
+  }
+}
@@ -37,7 +37,7 @@ import {
 import { toAgentPayload } from "./agent-projections.js";
 import { curateAgentActivity } from "./activity-curator.js";
 import { AGENT_PROVIDER_DEFINITIONS } from "./provider-registry.js";
-import { AgentStorage } from "./agent-storage.js";
+import type { AgentSnapshotStore } from "./agent-snapshot-store.js";
 import {
  appendTimelineItemIfAgentKnown,
  emitLiveTimelineItemIfAgentKnown,
@@ -51,7 +51,7 @@ import { createAgentWorktree, runAsyncWorktreeBootstrap } from "../worktree-boot

 export interface AgentManagementMcpOptions {
  agentManager: AgentManager;
-  agentStorage: AgentStorage;
+  agentStorage: AgentSnapshotStore;
  terminalManager?: TerminalManager | null;
  paseoHome?: string;
  logger: Logger;
@@ -178,7 +178,7 @@ function sanitizePermissionRequest(
 }

 async function resolveAgentTitle(
-  agentStorage: AgentStorage,
+  agentStorage: AgentSnapshotStore,
  agentId: string,
  logger: Logger,
 ): Promise<string | null> {
@@ -192,7 +192,7 @@ async function resolveAgentTitle(
 }

 async function serializeSnapshotWithMetadata(
-  agentStorage: AgentStorage,
+  agentStorage: AgentSnapshotStore,
  snapshot: ManagedAgent,
  logger: Logger,
 ) {
@@ -0,0 +1,14 @@
+import type { ManagedAgent } from "./agent-manager.js";
+import type { StoredAgentRecord } from "./agent-storage.js";
+
+export interface AgentSnapshotStore {
+  list(): Promise<StoredAgentRecord[]>;
+  get(agentId: string): Promise<StoredAgentRecord | null>;
+  upsert(record: StoredAgentRecord): Promise<void>;
+  remove(agentId: string): Promise<void>;
+  applySnapshot(
+    agent: ManagedAgent,
+    options?: { title?: string | null; internal?: boolean },
+  ): Promise<void>;
+  setTitle(agentId: string, title: string): Promise<void>;
+}
@@ -1,7 +1,7 @@
 import { describe, expect, test, beforeEach, afterEach } from "vitest";
 import os from "node:os";
 import path from "node:path";
-import { mkdtempSync, readdirSync, rmSync } from "node:fs";
+import { mkdtempSync, rmSync } from "node:fs";
 import { promises as fs } from "node:fs";

 import { createTestLogger } from "../../test-utils/test-logger.js";
@@ -352,24 +352,6 @@ describe("AgentStorage", () => {
    expect(records[0]?.internal).toBe(true);
  });

-  test("Windows drive-letter paths produce valid directory names", async () => {
-    await storage.applySnapshot(
-      createManagedAgent({
-        id: "win-agent",
-        cwd: "D:\\Users\\dev\\MyProject",
-      }),
-    );
-
-    const record = await storage.get("win-agent");
-    expect(record).not.toBeNull();
-
-    // The persisted directory must not contain a colon (invalid on Windows)
-    const dirs = readdirSync(storagePath);
-    expect(dirs).toHaveLength(1);
-    expect(dirs[0]).not.toContain(":");
-    expect(dirs[0]).toBe("D-Users-dev-MyProject");
-  });
-
  test("remove deletes all duplicate record files across project directories", async () => {
    const agentId = "agent-duplicate";

@@ -7,6 +7,7 @@ import type { Logger } from "pino";
 import { AgentStatusSchema } from "../messages.js";
 import { toStoredAgentRecord } from "./agent-projections.js";
 import type { ManagedAgent } from "./agent-manager.js";
+import type { AgentSnapshotStore } from "./agent-snapshot-store.js";
 import type { AgentSessionConfig } from "./agent-sdk-types.js";

 const SERIALIZABLE_CONFIG_SCHEMA = z
@@ -69,8 +70,11 @@ export type SerializableAgentConfig = Pick<
 >;

 export type StoredAgentRecord = z.infer<typeof STORED_AGENT_SCHEMA>;
+export function parseStoredAgentRecord(value: unknown): StoredAgentRecord {
+  return STORED_AGENT_SCHEMA.parse(value);
+}

-export class AgentStorage {
+export class AgentStorage implements AgentSnapshotStore {
  private cache: Map<string, StoredAgentRecord> = new Map();
  private pathById: Map<string, string> = new Map();
  private pathsById: Map<string, Set<string>> = new Map();
@@ -300,7 +304,7 @@ export class AgentStorage {
    try {
      const content = await fs.readFile(filePath, "utf8");
      const parsed = JSON.parse(content);
-      return STORED_AGENT_SCHEMA.parse(parsed);
+      return parseStoredAgentRecord(parsed);
    } catch (error) {
      this.logger.error({ err: error, filePath }, "Skipping invalid agent record");
      return null;
@@ -335,16 +339,11 @@ export class AgentStorage {
 }

 function projectDirNameFromCwd(cwd: string): string {
-  // path.win32.parse handles drive letters, UNC roots, and Unix roots on all platforms
-  const { root } = path.win32.parse(cwd);
-  const withoutRoot = cwd.slice(root.length).replace(/[\\/]+$/, "");
-  // Sanitize root: strip colons and separators, keep letters (e.g. "C:\" → "C", "\\server\share\" → "server-share")
-  const sanitizedRoot = root.replace(/[:\\/]+/g, "-").replace(/^-+|-+$/g, "");
-  const prefix = sanitizedRoot ? sanitizedRoot + "-" : "";
-  if (!withoutRoot) {
-    return sanitizedRoot || "root";
+  const trimmed = cwd.replace(/^[\\/]+/, "").replace(/[\\/]+$/, "");
+  if (!trimmed) {
+    return "root";
  }
-  return prefix + withoutRoot.replace(/[\\/]+/g, "-");
+  return trimmed.replace(/[\\/]+/g, "-");
 }

 async function writeFileAtomically(targetPath: string, payload: string) {
@@ -0,0 +1,60 @@
+import type { AgentTimelineItem } from "./agent-sdk-types.js";
+
+export type AgentTimelineRow = {
+  seq: number;
+  timestamp: string;
+  item: AgentTimelineItem;
+};
+
+export type AgentTimelineCursor = {
+  seq: number;
+};
+
+export type AgentTimelineFetchDirection = "tail" | "before" | "after";
+
+export type AgentTimelineFetchOptions = {
+  direction?: AgentTimelineFetchDirection;
+  cursor?: AgentTimelineCursor;
+  /**
+   * Number of canonical rows to return.
+   * - undefined: store default
+   * - 0: all rows in the selected window
+   */
+  limit?: number;
+};
+
+export type AgentTimelineWindow = {
+  minSeq: number;
+  maxSeq: number;
+  nextSeq: number;
+};
+
+export type AgentTimelineFetchResult = {
+  direction: AgentTimelineFetchDirection;
+  window: AgentTimelineWindow;
+  hasOlder: boolean;
+  hasNewer: boolean;
+  rows: AgentTimelineRow[];
+};
+
+export interface AgentTimelineStore {
+  appendCommitted(
+    agentId: string,
+    item: AgentTimelineItem,
+    options?: { timestamp?: string },
+  ): Promise<AgentTimelineRow>;
+  fetchCommitted(
+    agentId: string,
+    options?: AgentTimelineFetchOptions,
+  ): Promise<AgentTimelineFetchResult>;
+  getLatestCommittedSeq(agentId: string): Promise<number>;
+  getCommittedRows(agentId: string): Promise<AgentTimelineRow[]>;
+  getLastItem(agentId: string): Promise<AgentTimelineItem | null>;
+  getLastAssistantMessage(agentId: string): Promise<string | null>;
+  hasCommittedUserMessage(
+    agentId: string,
+    options: { messageId: string; text: string },
+  ): Promise<boolean>;
+  deleteAgent(agentId: string): Promise<void>;
+  bulkInsert(agentId: string, rows: readonly AgentTimelineRow[]): Promise<void>;
+}
@@ -0,0 +1,244 @@
+import type { AgentTimelineItem } from "./agent-sdk-types.js";
+import type {
+  AgentTimelineFetchOptions,
+  AgentTimelineFetchResult,
+  AgentTimelineRow,
+} from "./agent-timeline-store-types.js";
+
+export type SeedAgentTimelineOptions = {
+  items?: readonly AgentTimelineItem[];
+  rows?: readonly AgentTimelineRow[];
+  nextSeq?: number;
+  timestamp?: string;
+};
+
+type AgentTimelineState = {
+  rows: AgentTimelineRow[];
+  nextSeq: number;
+};
+
+const DEFAULT_TIMELINE_FETCH_LIMIT = 200;
+
+function cloneRow(row: AgentTimelineRow): AgentTimelineRow {
+  return { ...row };
+}
+
+function normalizeTimelineMessageId(messageId: string | undefined): string | undefined {
+  if (typeof messageId !== "string") {
+    return undefined;
+  }
+  const normalized = messageId.trim();
+  return normalized.length > 0 ? normalized : undefined;
+}
+
+export class InMemoryAgentTimelineStore {
+  private readonly states = new Map<string, AgentTimelineState>();
+
+  has(agentId: string): boolean {
+    return this.states.has(agentId);
+  }
+
+  initialize(agentId: string, options?: SeedAgentTimelineOptions): void {
+    const timestamp = options?.timestamp ?? new Date().toISOString();
+    const rows = options?.rows?.length
+      ? options.rows.map(cloneRow)
+      : this.buildRowsFromItems(options?.items ?? [], options?.nextSeq ?? 1, timestamp);
+    const nextSeq =
+      options?.nextSeq ?? (rows.length ? rows[rows.length - 1]!.seq + 1 : 1);
+    this.states.set(agentId, {
+      rows,
+      nextSeq,
+    });
+  }
+
+  delete(agentId: string): void {
+    this.states.delete(agentId);
+  }
+
+  getItems(agentId: string): AgentTimelineItem[] {
+    return this.requireState(agentId).rows.map((row) => row.item);
+  }
+
+  getRows(agentId: string): AgentTimelineRow[] {
+    return this.requireState(agentId).rows.map(cloneRow);
+  }
+
+  fetch(agentId: string, options?: AgentTimelineFetchOptions): AgentTimelineFetchResult {
+    const state = this.requireState(agentId);
+    const direction = options?.direction ?? "tail";
+    const requestedLimit = options?.limit;
+    const limit =
+      requestedLimit === undefined
+        ? DEFAULT_TIMELINE_FETCH_LIMIT
+        : Math.max(0, Math.floor(requestedLimit));
+    const cursor = options?.cursor;
+    const minSeq = state.rows.length ? state.rows[0]!.seq : 0;
+    const maxSeq = state.rows.length ? state.rows[state.rows.length - 1]!.seq : 0;
+    const selectAll = limit === 0;
+
+    const window = {
+      minSeq,
+      maxSeq,
+      nextSeq: state.nextSeq,
+    };
+
+    if (state.rows.length === 0) {
+      return {
+        direction,
+        window,
+        hasOlder: false,
+        hasNewer: false,
+        rows: [],
+      };
+    }
+
+    if (direction === "tail") {
+      const selected =
+        selectAll || limit >= state.rows.length ? state.rows : state.rows.slice(state.rows.length - limit);
+      return {
+        direction,
+        window,
+        hasOlder: selected.length > 0 && selected[0]!.seq > minSeq,
+        hasNewer: false,
+        rows: selected.map(cloneRow),
+      };
+    }
+
+    if (direction === "after") {
+      const baseSeq = cursor?.seq ?? 0;
+      const startIdx = state.rows.findIndex((row) => row.seq > baseSeq);
+      if (startIdx < 0) {
+        return {
+          direction,
+          window,
+          hasOlder: baseSeq >= minSeq,
+          hasNewer: false,
+          rows: [],
+        };
+      }
+
+      const selected = selectAll
+        ? state.rows.slice(startIdx)
+        : state.rows.slice(startIdx, startIdx + limit);
+      const lastSelected = selected[selected.length - 1];
+      return {
+        direction,
+        window,
+        hasOlder: selected[0]!.seq > minSeq,
+        hasNewer: Boolean(lastSelected && lastSelected.seq < maxSeq),
+        rows: selected.map(cloneRow),
+      };
+    }
+
+    const beforeSeq = cursor?.seq ?? state.nextSeq;
+    const endExclusive = state.rows.findIndex((row) => row.seq >= beforeSeq);
+    const boundedRows = endExclusive < 0 ? state.rows : state.rows.slice(0, endExclusive);
+    const selected =
+      selectAll || limit >= boundedRows.length
+        ? boundedRows
+        : boundedRows.slice(boundedRows.length - limit);
+    return {
+      direction,
+      window,
+      hasOlder: selected.length > 0 && selected[0]!.seq > minSeq,
+      hasNewer: endExclusive >= 0,
+      rows: selected.map(cloneRow),
+    };
+  }
+
+  append(
+    agentId: string,
+    item: AgentTimelineItem,
+    options?: { timestamp?: string },
+  ): AgentTimelineRow {
+    const state = this.requireState(agentId);
+    const row: AgentTimelineRow = {
+      seq: state.nextSeq,
+      timestamp: options?.timestamp ?? new Date().toISOString(),
+      item,
+    };
+    state.nextSeq += 1;
+    state.rows.push(row);
+    return cloneRow(row);
+  }
+
+  getLastItem(agentId: string): AgentTimelineItem | null {
+    const state = this.requireState(agentId);
+    return state.rows[state.rows.length - 1]?.item ?? null;
+  }
+
+  getLastAssistantMessage(agentId: string): string | null {
+    const rows = this.requireState(agentId).rows;
+    const chunks: string[] = [];
+    for (let i = rows.length - 1; i >= 0; i -= 1) {
+      const item = rows[i]!.item;
+      if (item.type !== "assistant_message") {
+        if (chunks.length > 0) {
+          break;
+        }
+        continue;
+      }
+      chunks.push(item.text);
+    }
+
+    if (chunks.length === 0) {
+      return null;
+    }
+
+    return chunks.reverse().join("");
+  }
+
+  getCanonicalUserMessagesById(agentId: string): Map<string, string> {
+    const entries = this.requireState(agentId).rows.flatMap<[string, string]>((row) => {
+      if (row.item.type !== "user_message") {
+        return [];
+      }
+      const messageId = normalizeTimelineMessageId(row.item.messageId);
+      if (!messageId) {
+        return [];
+      }
+      return [[messageId, row.item.text]];
+    });
+    return new Map(entries);
+  }
+
+  hasCommittedUserMessage(agentId: string, options: { messageId: string; text: string }): boolean {
+    const messageId = normalizeTimelineMessageId(options.messageId);
+    if (!messageId) {
+      return false;
+    }
+
+    return this.requireState(agentId).rows.some((row) => {
+      if (row.item.type !== "user_message") {
+        return false;
+      }
+      const rowMessageId = normalizeTimelineMessageId(row.item.messageId);
+      return rowMessageId === messageId && row.item.text === options.text;
+    });
+  }
+
+  private requireState(agentId: string): AgentTimelineState {
+    const state = this.states.get(agentId);
+    if (!state) {
+      throw new Error(`Unknown agent '${agentId}'`);
+    }
+    return state;
+  }
+
+  private buildRowsFromItems(
+    items: readonly AgentTimelineItem[],
+    startSeq: number,
+    timestamp: string,
+  ): AgentTimelineRow[] {
+    let nextSeq = startSeq;
+    return items.map((item) => {
+      const row: AgentTimelineRow = {
+        seq: nextSeq,
+        timestamp,
+        item,
+      };
+      nextSeq += 1;
+      return row;
+    });
+  }
+}
@@ -6,11 +6,11 @@ import { tmpdir } from "node:os";
 import { createTestLogger } from "../../test-utils/test-logger.js";
 import { createAgentMcpServer } from "./mcp-server.js";
 import type { AgentManager, ManagedAgent } from "./agent-manager.js";
-import type { AgentStorage } from "./agent-storage.js";
+import type { AgentSnapshotStore } from "./agent-snapshot-store.js";

 type TestDeps = {
  agentManager: AgentManager;
-  agentStorage: AgentStorage;
+  agentStorage: AgentSnapshotStore;
  spies: {
    agentManager: Record<string, any>;
    agentStorage: Record<string, any>;
@@ -41,7 +41,7 @@ function createTestDeps(): TestDeps {

  return {
    agentManager: agentManagerSpies as unknown as AgentManager,
-    agentStorage: agentStorageSpies as unknown as AgentStorage,
+    agentStorage: agentStorageSpies as unknown as AgentSnapshotStore,
    spies: {
      agentManager: agentManagerSpies,
      agentStorage: agentStorageSpies,
@@ -16,7 +16,7 @@ import {
 import { toAgentPayload } from "./agent-projections.js";
 import { curateAgentActivity } from "./activity-curator.js";
 import { AGENT_PROVIDER_DEFINITIONS } from "./provider-registry.js";
-import { AgentStorage } from "./agent-storage.js";
+import type { AgentSnapshotStore } from "./agent-snapshot-store.js";
 import {
  appendTimelineItemIfAgentKnown,
  emitLiveTimelineItemIfAgentKnown,
@@ -31,7 +31,7 @@ import { createAgentWorktree, runAsyncWorktreeBootstrap } from "../worktree-boot

 export interface AgentMcpServerOptions {
  agentManager: AgentManager;
-  agentStorage: AgentStorage;
+  agentStorage: AgentSnapshotStore;
  terminalManager?: TerminalManager | null;
  paseoHome?: string;
  /**
@@ -240,7 +240,7 @@ function sanitizePermissionRequest(
 }

 async function resolveAgentTitle(
-  agentStorage: AgentStorage,
+  agentStorage: AgentSnapshotStore,
  agentId: string,
  logger: Logger,
 ): Promise<string | null> {
@@ -254,7 +254,7 @@ async function resolveAgentTitle(
 }

 async function serializeSnapshotWithMetadata(
-  agentStorage: AgentStorage,
+  agentStorage: AgentSnapshotStore,
  snapshot: ManagedAgent,
  logger: Logger,
 ) {
@@ -1,7 +1,6 @@
 import { afterEach, beforeEach, describe, expect, test } from "vitest";
 import { execFileSync } from "node:child_process";

-import type { AgentModelDefinition } from "../agent-sdk-types.js";
 import { createDaemonTestContext, type DaemonTestContext } from "../test-utils/index.js";

 function isBinaryInstalled(binary: string): boolean {
@@ -16,16 +15,6 @@ function isBinaryInstalled(binary: string): boolean {
 const hasCodex = isBinaryInstalled("codex");
 const hasOpenCode = isBinaryInstalled("opencode");

-function modelMatchesFamily(
-  model: AgentModelDefinition,
-  family: "sonnet" | "haiku",
-): boolean {
-  const haystacks = [model.id, model.label, model.description ?? ""].map((value) =>
-    value.toLowerCase(),
-  );
-  return haystacks.some((text) => text.includes(family));
-}
-
 describe("provider model catalogs (e2e)", () => {
  let ctx: DaemonTestContext;

@@ -43,8 +32,11 @@ describe("provider model catalogs (e2e)", () => {
    expect(result.error).toBeNull();
    expect(result.models.length).toBeGreaterThan(0);

-    expect(result.models.some((model) => modelMatchesFamily(model, "sonnet"))).toBe(true);
-    expect(result.models.some((model) => modelMatchesFamily(model, "haiku"))).toBe(true);
+    const descriptions = result.models.map((model) =>
+      `${model.label} ${model.description ?? ""}`.toLowerCase(),
+    );
+    expect(descriptions.some((text) => text.includes("sonnet 4.5"))).toBe(true);
+    expect(descriptions.some((text) => text.includes("haiku"))).toBe(true);
  }, 180_000);

  test.runIf(hasCodex)(
@@ -336,7 +336,11 @@ describe("Agent event stream redesign — integration", () => {
    const handle = await createSession({ cwdPrefix: "event-stream-interrupt-" });

    try {
-      let turnId: string | null = null;
+      const { turnId } = await handle.session.startTurn(
+        "write a very long essay about the history of computing",
+      );
+
+      // Use a single subscription to avoid missing events between unsubscribe/resubscribe
      const events = await new Promise<AgentStreamEvent[]>((resolve, reject) => {
        const collected: AgentStreamEvent[] = [];
        let interrupted = false;
@@ -348,14 +352,10 @@ describe("Agent event stream redesign — integration", () => {

        const unsubscribe = handle.session.subscribe((event) => {
          collected.push(event);
-          if (!turnId && event.type === "turn_started" && hasTurnId(event)) {
-            turnId = event.turnId;
-          }

          // Once we see turn_started, fire the interrupt
          if (
            !interrupted &&
-            turnId &&
            event.type === "turn_started" &&
            hasTurnId(event) &&
            event.turnId === turnId
@@ -365,37 +365,14 @@ describe("Agent event stream redesign — integration", () => {
          }

          // Resolve when we get a terminal event for this turn
-          if (turnId && isTerminalEvent(event) && hasTurnId(event) && event.turnId === turnId) {
+          if (isTerminalEvent(event) && hasTurnId(event) && event.turnId === turnId) {
            clearTimeout(timeout);
            unsubscribe();
            resolve(collected);
          }
        });
-
-        void handle.session
-          .startTurn("write a very long essay about the history of computing")
-          .then((result) => {
-            if (turnId && turnId !== result.turnId) {
-              clearTimeout(timeout);
-              unsubscribe();
-              reject(
-                new Error(
-                  `Observed turn_started for ${turnId} but startTurn returned ${result.turnId}`,
-                ),
-              );
-              return;
-            }
-            turnId = result.turnId;
-          })
-          .catch((error) => {
-            clearTimeout(timeout);
-            unsubscribe();
-            reject(error);
-          });
      });

-      expect(turnId).toBeDefined();
-
      // turn_canceled or turn_failed arrives for that turnId
      const terminal = events.find(
        (e) =>
@@ -441,7 +441,7 @@ describe("ClaudeAgentSession redesign invariants", () => {
    }
  });

-  test("waits for complete JSON values before updating tool input from input_json_delta", async () => {
+  test("routes input_json_delta through partial parsing before buffered JSON is complete", async () => {
    const session = await createSession();
    const internal = session as unknown as {
      mapPartialEvent: (event: Record<string, unknown>) => AgentTimelineItem[];
@@ -479,7 +479,7 @@ describe("ClaudeAgentSession redesign invariants", () => {
              partial_json: '{"command":"echo ',
            },
          },
-          expectedCommand: "echo seed",
+          expectedCommand: "echo ",
        },
        {
          event: {
@@ -520,7 +520,7 @@ describe("ClaudeAgentSession redesign invariants", () => {
    }
  });

-  test("does not surface incomplete string values from input_json_delta", async () => {
+  test("surfaces canonical partial tool input from input_json_delta before JSON is complete", async () => {
    const session = await createSession();
    const internal = session as unknown as {
      mapPartialEvent: (event: Record<string, unknown>) => AgentTimelineItem[];
@@ -551,6 +551,7 @@ describe("ClaudeAgentSession redesign invariants", () => {

      expect(internal.toolUseCache.get(toolUseId)?.input).toEqual({
        file_path: "src/message.tsx",
+        old_string: "before",
      });
    } finally {
      await session.close();
@@ -1,5 +1,5 @@
 import { describe, expect, test, vi } from "vitest";
-import type { ModelInfo } from "@anthropic-ai/claude-agent-sdk";
+import type { ModelInfo, SDKUserMessage } from "@anthropic-ai/claude-agent-sdk";

 import { createTestLogger } from "../../../test-utils/test-logger.js";
 import { ClaudeAgentClient, convertClaudeHistoryEntry } from "./claude-agent.js";
@@ -357,4 +357,52 @@ describe("ClaudeAgentClient.listModels", () => {
    ]);
    expect(queryMock.return).toHaveBeenCalledTimes(1);
  });
+
+  test("keeps the Claude control-plane query open until supportedModels resolves", async () => {
+    const queryMock = createSupportedModelsQueryMock([
+      {
+        value: "default",
+        displayName: "Default (recommended)",
+        description: "Sonnet 4.6 · Best for everyday tasks",
+      },
+    ] satisfies ModelInfo[]);
+    let promptIterator: AsyncIterator<SDKUserMessage, void> | null = null;
+    let promptNextPromise: Promise<IteratorResult<SDKUserMessage, void>> | null = null;
+    let promptClosedBeforeModelsResolved = false;
+
+    queryMock.supportedModels = vi.fn(async () => {
+      promptNextPromise = promptIterator?.next() ?? null;
+      if (!promptNextPromise) {
+        throw new Error("Prompt iterator not captured");
+      }
+      promptNextPromise.then(() => {
+        promptClosedBeforeModelsResolved = true;
+      });
+      await Promise.resolve();
+      expect(promptClosedBeforeModelsResolved).toBe(false);
+      return [
+        {
+          value: "default",
+          displayName: "Default (recommended)",
+          description: "Sonnet 4.6 · Best for everyday tasks",
+        },
+      ] satisfies ModelInfo[];
+    });
+
+    const queryFactory = vi.fn(({ prompt }) => {
+      promptIterator = prompt[Symbol.asyncIterator]();
+      return queryMock;
+    });
+    const client = new ClaudeAgentClient({
+      logger,
+      queryFactory: queryFactory as never,
+    });
+
+    const models = await client.listModels({ cwd: process.cwd() });
+
+    expect(models).toHaveLength(1);
+    expect(promptNextPromise).not.toBeNull();
+    await expect(promptNextPromise).resolves.toEqual({ done: true, value: undefined });
+    expect(queryMock.return).toHaveBeenCalledTimes(1);
+  });
 });
@@ -67,11 +67,7 @@ import type {
  McpServerConfig,
  PersistedAgentDescriptor,
 } from "../agent-sdk-types.js";
-import {
-  applyProviderEnv,
-  findExecutable,
-  type ProviderRuntimeSettings,
-} from "../provider-launch-config.js";
+import { applyProviderEnv, type ProviderRuntimeSettings } from "../provider-launch-config.js";
 import { getOrchestratorModeInstructions } from "../orchestrator-instructions.js";

 const fsPromises = promises;
@@ -205,14 +201,11 @@ function applyRuntimeSettingsToClaudeOptions(
    ...options,
    spawnClaudeCodeProcess: (spawnOptions) => {
      const resolved = resolveClaudeSpawnCommand(spawnOptions, runtimeSettings);
-      // When the SDK passes a default JS runtime ("node"/"bun"), replace it with
-      // process.execPath — the actual node binary running the daemon. This avoids
-      // PATH lookup failures in the managed runtime bundle.
-      // When the SDK passes a native binary path (from pathToClaudeCodeExecutable)
-      // or the user overrides the command via runtime settings, use that directly.
-      const isDefaultRuntime =
-        resolved.command === "node" || resolved.command === "bun";
-      const command = isDefaultRuntime ? process.execPath : resolved.command;
+      // The SDK defaults to spawning "node" via PATH lookup, which fails when
+      // running from the managed runtime bundle where node isn't in PATH.
+      // Always use process.execPath — the actual node binary running the daemon.
+      const command =
+        resolved.command === spawnOptions.command ? process.execPath : resolved.command;
      const child = spawn(command, resolved.args, {
        cwd: spawnOptions.cwd,
        env: {
@@ -232,10 +225,6 @@ function applyRuntimeSettingsToClaudeOptions(
  };
 }

-function createEmptyClaudePrompt(): AsyncGenerator<SDKUserMessage, void, undefined> {
-  return (async function* empty() {})();
-}
-
 function isClaudeThinkingEffort(value: string | null | undefined): value is ClaudeThinkingEffort {
  return value === "low" || value === "medium" || value === "high" || value === "max";
 }
@@ -1039,8 +1028,9 @@ export class ClaudeAgentClient implements AgentClient {
  }

  async listModels(options?: ListModelsOptions): Promise<AgentModelDefinition[]> {
+    const input = createAsyncMessageInput<SDKUserMessage>();
    const claudeQuery = this.queryFactory({
-      prompt: createEmptyClaudePrompt(),
+      prompt: input.iterable,
      options: applyRuntimeSettingsToClaudeOptions(
        {
          cwd: options?.cwd ?? process.cwd(),
@@ -1059,13 +1049,13 @@ export class ClaudeAgentClient implements AgentClient {
      this.logger.warn({ err: error }, "Failed to query Claude supportedModels()");
      throw error;
    } finally {
+      input.end();
      try {
        await claudeQuery.return?.();
      } catch {
        // ignore control-plane shutdown errors
      }
    }
-
  }

  async listPersistedAgents(
@@ -1862,14 +1852,12 @@ class ClaudeAgentSession implements AgentSession {
      .filter((entry): entry is string => typeof entry === "string" && entry.length > 0)
      .join("\n\n");

-    const claudeBinary = findExecutable("claude");
    const base: ClaudeOptions = {
      cwd: this.config.cwd,
      includePartialMessages: true,
      permissionMode: this.currentMode,
      agents: this.defaults?.agents,
      canUseTool: this.handlePermissionRequest,
-      ...(claudeBinary ? { pathToClaudeCodeExecutable: claudeBinary } : {}),
      // Use Claude Code preset system prompt and load CLAUDE.md files
      // Append provider-agnostic system prompt and orchestrator instructions for agents.
      systemPrompt: {
@@ -13,25 +13,33 @@ describe("parsePartialJsonObject", () => {
    });
  });

-  it("does not emit incomplete string values", () => {
+  it("keeps partial string values without field-specific logic", () => {
    expect(parsePartialJsonObject('{"command":"echo ')).toEqual({
-      value: {},
-      complete: false,
-    });
-  });
-
-  it("returns only complete prefix fields from incomplete objects", () => {
-    expect(parsePartialJsonObject('{"file_path":"src/message.tsx","old_string":"before')).toEqual({
      value: {
-        file_path: "src/message.tsx",
+        command: "echo ",
      },
      complete: false,
    });
  });

-  it("does not emit incomplete nested values", () => {
+  it("returns parsed prefix fields from incomplete objects", () => {
+    expect(parsePartialJsonObject('{"file_path":"src/message.tsx","old_string":"before')).toEqual({
+      value: {
+        file_path: "src/message.tsx",
+        old_string: "before",
+      },
+      complete: false,
+    });
+  });
+
+  it("parses nested partial values generically", () => {
    expect(parsePartialJsonObject('{"payload":{"path":"src/index.ts","content":"hello')).toEqual({
-      value: {},
+      value: {
+        payload: {
+          path: "src/index.ts",
+          content: "hello",
+        },
+      },
      complete: false,
    });
  });
@@ -271,17 +271,17 @@ function parsePartialObject(
      };
    }

+    value[parsedKey.value] = parsedMemberValue.value;
+    currentIndex = skipWhitespace(input, parsedMemberValue.nextIndex);
+
    if (!parsedMemberValue.complete) {
      return {
        value,
-        nextIndex: skipWhitespace(input, parsedMemberValue.nextIndex),
+        nextIndex: currentIndex,
        complete: false,
      };
    }

-    value[parsedKey.value] = parsedMemberValue.value;
-    currentIndex = skipWhitespace(input, parsedMemberValue.nextIndex);
-
    const delimiter = input[currentIndex];
    if (delimiter === ",") {
      currentIndex += 1;
@@ -579,127 +579,4 @@ describe("codex tool-call mapper", () => {

    expect(item).toBeNull();
  });
-
-  it("maps apply_patch with Delete File directive into edit detail with removed lines", () => {
-    const patch = [
-      "*** Begin Patch",
-      "*** Delete File: /tmp/repo/src/dead-module.ts",
-      "*** End Patch",
-    ].join("\n");
-    const item = expectMapped(
-      mapCodexRolloutToolCall({
-        callId: "codex-delete-rollout",
-        name: "apply_patch",
-        input: patch,
-        output:
-          '{"output":"Success. Updated the following files:\\nD /tmp/repo/src/dead-module.ts\\n"}',
-        cwd: "/tmp/repo",
-      }),
-    );
-
-    expect(item.status).toBe("completed");
-    expect(item.detail.type).toBe("edit");
-    if (item.detail.type === "edit") {
-      expect(item.detail.filePath).toBe("src/dead-module.ts");
-      expect(item.detail.unifiedDiff).toContain("/dev/null");
-    }
-  });
-
-  it("maps multi-file apply_patch with update + delete into edit detail referencing the deleted file", () => {
-    // Exact data shape from real Codex rollout: update one file, delete another
-    const patch = [
-      "*** Begin Patch",
-      "*** Update File: /tmp/repo/src/app/index.tsx",
-      "@@",
-      ' import { useEffect } from "react";',
-      '-import { WELCOME_ROUTE } from "@/app-support/index-startup";',
-      "+",
-      '+const WELCOME_ROUTE = "/welcome";',
-      "*** Delete File: /tmp/repo/src/app-support/index-startup.ts",
-      "*** End Patch",
-    ].join("\n");
-
-    const item = expectMapped(
-      mapCodexRolloutToolCall({
-        callId: "codex-delete-multi",
-        name: "apply_patch",
-        input: patch,
-        output: JSON.stringify({
-          output:
-            "Success. Updated the following files:\nM /tmp/repo/src/app/index.tsx\nD /tmp/repo/src/app-support/index-startup.ts\n",
-          metadata: { exit_code: 0, duration_seconds: 0.0 },
-        }),
-        cwd: "/tmp/repo",
-      }),
-    );
-
-    expect(item.detail.type).toBe("edit");
-    if (item.detail.type === "edit") {
-      // The unified diff should contain both file sections
-      const diff = item.detail.unifiedDiff ?? "";
-      // The update file section should have normal diff lines
-      expect(diff).toContain("-import");
-      expect(diff).toContain("+const WELCOME_ROUTE");
-      // The delete file section should reference /dev/null
-      expect(diff).toContain("/dev/null");
-    }
-  });
-
-  it("maps fileChange delete with content as removed lines, not added lines", () => {
-    const item = mapCodexToolCallFromThreadItem(
-      {
-        type: "fileChange",
-        id: "codex-file-delete-with-content",
-        status: "completed",
-        changes: [
-          {
-            path: "/tmp/repo/src/dead-module.ts",
-            kind: "delete",
-            content: 'export const FOO = "bar";\nexport function hello() {}\n',
-          },
-        ],
-      },
-      { cwd: "/tmp/repo" },
-    );
-
-    expect(item).toBeTruthy();
-    expect(item?.detail.type).toBe("edit");
-    if (item?.detail.type === "edit") {
-      expect(item.detail.filePath).toBe("src/dead-module.ts");
-      const diff = item.detail.unifiedDiff ?? "";
-      // For a deletion, the content should appear as REMOVED lines (-)
-      // not as ADDED lines (+). This is the core bug.
-      expect(diff).toContain("/dev/null");
-      expect(diff).toContain("-export const FOO");
-      expect(diff).toContain("-export function hello");
-      // The content must NOT appear as added lines
-      expect(diff).not.toContain("+export const FOO");
-      expect(diff).not.toContain("+export function hello");
-    }
-  });
-
-  it("maps fileChange delete without content to edit detail with /dev/null marker", () => {
-    const item = mapCodexToolCallFromThreadItem(
-      {
-        type: "fileChange",
-        id: "codex-file-delete-no-content",
-        status: "completed",
-        changes: [
-          {
-            path: "/tmp/repo/src/dead-module.ts",
-            kind: "delete",
-          },
-        ],
-      },
-      { cwd: "/tmp/repo" },
-    );
-
-    expect(item).toBeTruthy();
-    // A delete without content should still produce a meaningful detail
-    if (item?.detail.type === "edit") {
-      expect(item.detail.filePath).toBe("src/dead-module.ts");
-      const diff = item.detail.unifiedDiff ?? "";
-      expect(diff).toContain("/dev/null");
-    }
-  });
 });
@@ -347,7 +347,7 @@ function normalizeDiffHeaderPath(rawPath: string): string {
 function codexApplyPatchToUnifiedDiff(text: string): string {
  const lines = text.replace(/\r\n/g, "\n").split("\n");
  const output: string[] = [];
-  let sawDiffContent = false;
+  let sawDiffBody = false;

  for (const line of lines) {
    const directive = parseCodexApplyPatchDirective(line);
@@ -362,7 +362,6 @@ function codexApplyPatchToUnifiedDiff(text: string): string {
        output.push(`diff --git a/${path} b/${path}`);
        output.push(`--- ${left}`);
        output.push(`+++ ${right}`);
-        sawDiffContent = true;
      }
      continue;
    }
@@ -379,22 +378,22 @@ function codexApplyPatchToUnifiedDiff(text: string): string {

    if (line.startsWith("@@")) {
      output.push(line);
-      sawDiffContent = true;
+      sawDiffBody = true;
      continue;
    }
    if (line.startsWith("+") || line.startsWith("-") || line.startsWith(" ")) {
      output.push(line);
-      sawDiffContent = true;
+      sawDiffBody = true;
      continue;
    }
    if (line.startsWith("\\ No newline at end of file")) {
      output.push(line);
-      sawDiffContent = true;
+      sawDiffBody = true;
      continue;
    }
  }

-  if (!sawDiffContent) {
+  if (!sawDiffBody) {
    return text;
  }

@@ -402,22 +401,6 @@ function codexApplyPatchToUnifiedDiff(text: string): string {
  return normalized.length > 0 ? normalized : text;
 }

-function contentToDeletionDiff(filePath: string, content: string): string {
-  const lines = content.replace(/\r\n/g, "\n").split("\n");
-  const output: string[] = [];
-  output.push(`diff --git a/${filePath} b/${filePath}`);
-  output.push(`--- a/${filePath}`);
-  output.push(`+++ /dev/null`);
-  const nonEmpty = lines.filter((l) => l.length > 0 || lines.indexOf(l) < lines.length - 1);
-  if (nonEmpty.length > 0) {
-    output.push(`@@ -1,${nonEmpty.length} +0,0 @@`);
-    for (const line of nonEmpty) {
-      output.push(`-${line}`);
-    }
-  }
-  return output.join("\n");
-}
-
 function classifyDiffLikeText(
  text: string,
 ): { isDiff: true; text: string } | { isDiff: false; text: string } {
@@ -733,26 +716,6 @@ function parseFileChangeEntries(
    .filter((entry): entry is CodexFileChangeEntry => entry !== null);
 }

-function resolveFileChangeTextFields(
-  file: CodexFileChangeEntry | undefined,
-): { unifiedDiff?: string; newString?: string } {
-  if (!file) {
-    return {};
-  }
-  const isDelete = file.kind === "delete";
-  if (isDelete && file.diff) {
-    const classified = classifyDiffLikeText(file.diff);
-    if (classified.isDiff) {
-      return { unifiedDiff: truncateDiffText(classified.text) };
-    }
-    return { unifiedDiff: truncateDiffText(contentToDeletionDiff(file.path, file.diff)) };
-  }
-  if (isDelete && !file.diff) {
-    return { unifiedDiff: contentToDeletionDiff(file.path, "") };
-  }
-  return asEditTextFields(file.diff);
-}
-
 function mapFileChangeItem(
  item: z.infer<typeof CodexFileChangeItemSchema>,
  options?: CodexMapperOptions,
@@ -776,9 +739,7 @@ function mapFileChangeItem(
          files: files.map((file) => ({
            path: file.path,
            ...(file.kind !== undefined ? { kind: file.kind } : {}),
-            ...(file.kind === "delete"
-              ? { patch: resolveFileChangeTextFields(file).unifiedDiff }
-              : asEditFileOutputFields(file.diff)),
+            ...asEditFileOutputFields(file.diff),
          })),
        }
      : {}),
@@ -788,7 +749,7 @@ function mapFileChangeItem(
  const error = item.error ?? null;
  const status = resolveStatus(item.status, error, output);
  const firstFile = files[0];
-  const firstTextFields = resolveFileChangeTextFields(firstFile);
+  const firstTextFields = asEditTextFields(firstFile?.diff);
  const hasFirstTextFields = Object.keys(firstTextFields).length > 0;
  const input = toNullableObject({
    ...inputBase,
@@ -597,42 +597,6 @@ function stringifyStructuredAssistantMessage(value: unknown): string | null {
  }
 }

-function readOpenCodeRecord(value: unknown): Record<string, unknown> | null {
-  return typeof value === "object" && value !== null && !Array.isArray(value)
-    ? (value as Record<string, unknown>)
-    : null;
-}
-
-function readNonEmptyString(value: unknown): string | null {
-  return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
-}
-
-function normalizeQuestionOptions(
-  value: unknown,
-): Array<{ label: string; description?: string }> | null {
-  if (!Array.isArray(value)) {
-    return null;
-  }
-
-  const options: Array<{ label: string; description?: string }> = [];
-  for (const item of value) {
-    if (typeof item === "string" && item.trim().length > 0) {
-      options.push({ label: item.trim() });
-      continue;
-    }
-
-    const record = readOpenCodeRecord(item);
-    const label = readNonEmptyString(record?.label);
-    if (!label) {
-      continue;
-    }
-    const description = readNonEmptyString(record?.description);
-    options.push(description ? { label, description } : { label });
-  }
-
-  return options;
-}
-
 export function translateOpenCodeEvent(
  event: unknown,
  state: OpenCodeEventTranslationState,
@@ -821,60 +785,6 @@ export function translateOpenCodeEvent(
      break;
    }

-    case "question.asked": {
-      const sessionId = props.sessionID as string | undefined;
-      if (sessionId !== state.sessionId) {
-        break;
-      }
-
-      const requestId = props.id as string | undefined;
-      const rawQuestions = Array.isArray(props.questions) ? props.questions : [];
-      if (!requestId || rawQuestions.length === 0) {
-        break;
-      }
-
-      const questions = rawQuestions.flatMap((item) => {
-        const questionRecord = readOpenCodeRecord(item);
-        const question = readNonEmptyString(questionRecord?.question);
-        const header = readNonEmptyString(questionRecord?.header);
-        if (!question || !header) {
-          return [];
-        }
-
-        const options = normalizeQuestionOptions(questionRecord?.options) ?? [];
-        return [
-          {
-            question,
-            header,
-            options,
-            ...(questionRecord?.multiple === true ? { multiSelect: true } : {}),
-          },
-        ];
-      });
-
-      if (questions.length === 0) {
-        break;
-      }
-
-      events.push({
-        type: "permission_requested",
-        provider: "opencode",
-        request: {
-          id: requestId,
-          provider: "opencode",
-          name: "question",
-          kind: "question",
-          title: "Question",
-          input: { questions },
-          metadata: {
-            source: "opencode_question",
-            ...(readOpenCodeRecord(props.tool) ?? {}),
-          },
-        },
-      });
-      break;
-    }
-
    case "session.idle": {
      const sessionId = props.sessionID as string | undefined;
      if (sessionId === state.sessionId) {
@@ -1286,38 +1196,6 @@ class OpenCodeAgentSession implements AgentSession {
      throw new Error(`No pending permission request with id '${requestId}'`);
    }

-    if (pending.kind === "question") {
-      if (response.behavior === "deny") {
-        await this.client.question.reject({
-          requestID: requestId,
-          directory: this.config.cwd,
-        });
-      } else {
-        const answersRecord = readOpenCodeRecord(response.updatedInput?.answers);
-        const questions = Array.isArray(pending.input?.questions) ? pending.input.questions : [];
-        const answers = questions.map((item) => {
-          const header = readNonEmptyString(readOpenCodeRecord(item)?.header);
-          const rawAnswer = header ? readNonEmptyString(answersRecord?.[header]) : null;
-          if (!rawAnswer) {
-            return [];
-          }
-          return rawAnswer
-            .split(",")
-            .map((entry) => entry.trim())
-            .filter((entry) => entry.length > 0);
-        });
-
-        await this.client.question.reply({
-          requestID: requestId,
-          directory: this.config.cwd,
-          answers,
-        });
-      }
-
-      this.pendingPermissions.delete(requestId);
-      return;
-    }
-
    const reply = response.behavior === "allow" ? "once" : "reject";
    await this.client.permission.reply({
      requestID: requestId,
@@ -0,0 +1,22 @@
+import { readFileSync } from "fs";
+import { fileURLToPath } from "url";
+import path from "path";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+// Load system prompt from agent-prompt.md in package root
+export function loadSystemPrompt(): string {
+  const promptPath = path.join(__dirname, "../../../agent-prompt.md");
+  return readFileSync(promptPath, "utf-8");
+}
+
+// Cache the loaded prompt
+let cachedPrompt: string | null = null;
+
+export function getSystemPrompt(): string {
+  if (!cachedPrompt) {
+    cachedPrompt = loadSystemPrompt();
+  }
+  return cachedPrompt;
+}
@@ -1,5 +1,6 @@
 import os from "node:os";
 import path from "node:path";
+import { existsSync, mkdirSync, writeFileSync } from "node:fs";
 import { mkdir, mkdtemp, rm } from "node:fs/promises";
 import { Writable } from "node:stream";
 import pino from "pino";
@@ -8,6 +9,8 @@ import { afterEach, describe, expect, test, vi } from "vitest";
 import { createPaseoDaemon, parseListenString, type PaseoDaemonConfig } from "./bootstrap.js";
 import { createTestPaseoDaemon } from "./test-utils/paseo-daemon.js";
 import { createTestAgentClients } from "./test-utils/fake-agent-client.js";
+import { openPaseoDatabase } from "./db/pglite-database.js";
+import { agentSnapshots, projects, workspaces } from "./db/schema.js";

 describe("paseo daemon bootstrap", () => {
  afterEach(() => {
@@ -122,23 +125,6 @@ describe("paseo daemon bootstrap", () => {
    }
  });

-  test("parses whitespace-padded numeric port strings", () => {
-    expect(parseListenString(" 6767 ")).toEqual({
-      type: "tcp",
-      host: "127.0.0.1",
-      port: 6767,
-    });
-  });
-
-  test("rejects Windows absolute paths that are not named pipes", () => {
-    // A Windows drive path like C:\daemon must NOT be silently parsed as TCP
-    // (split(":") would yield host="C" and port="\\daemon" which is nonsensical).
-    expect(() => parseListenString(String.raw`C:\daemon`)).toThrow();
-    expect(() => parseListenString(String.raw`D:\Users\foo\.paseo\daemon.sock`)).toThrow();
-    // Single-letter "host" with no valid port is not a valid listen string
-    expect(() => parseListenString(String.raw`C:\some\path`)).toThrow();
-  });
-
  test("parses Windows named pipes as managed IPC listen targets", () => {
    expect(parseListenString(String.raw`\\.\pipe\paseo-managed-test`)).toEqual({
      type: "pipe",
@@ -199,4 +185,224 @@ describe("paseo daemon bootstrap", () => {
      await rm(staticDir, { recursive: true, force: true });
    }
  });
+
+  test("imports legacy project and workspace JSON into the DB on first bootstrap", async () => {
+    const { config, cleanup } = await createBootstrapConfig();
+    writeLegacyProjectWorkspaceJson(config.paseoHome, {
+      projects: [
+        {
+          projectId: "project-1",
+          rootPath: "/tmp/project-1",
+          kind: "git",
+          displayName: "Project One",
+          createdAt: "2026-03-01T00:00:00.000Z",
+          updatedAt: "2026-03-02T00:00:00.000Z",
+          archivedAt: null,
+        },
+      ],
+      workspaces: [
+        {
+          workspaceId: "workspace-1",
+          projectId: "project-1",
+          cwd: "/tmp/project-1",
+          kind: "local_checkout",
+          displayName: "main",
+          createdAt: "2026-03-01T00:00:00.000Z",
+          updatedAt: "2026-03-02T00:00:00.000Z",
+          archivedAt: null,
+        },
+      ],
+    });
+
+    const daemon = await createPaseoDaemon(config, pino({ level: "silent" }));
+
+    try {
+      await daemon.start();
+      await daemon.stop();
+      const database = await openPaseoDatabase(path.join(config.paseoHome, "db"));
+      try {
+        expect(await database.db.select().from(projects)).toEqual([
+          {
+            projectId: "project-1",
+            rootPath: "/tmp/project-1",
+            kind: "git",
+            displayName: "Project One",
+            createdAt: "2026-03-01T00:00:00.000Z",
+            updatedAt: "2026-03-02T00:00:00.000Z",
+            archivedAt: null,
+          },
+        ]);
+        expect(await database.db.select().from(workspaces)).toEqual([
+          {
+            workspaceId: "workspace-1",
+            projectId: "project-1",
+            cwd: "/tmp/project-1",
+            kind: "local_checkout",
+            displayName: "main",
+            createdAt: "2026-03-01T00:00:00.000Z",
+            updatedAt: "2026-03-02T00:00:00.000Z",
+            archivedAt: null,
+          },
+        ]);
+      } finally {
+        await database.close();
+      }
+    } finally {
+      await cleanup();
+    }
+  });
+
+  test("does not duplicate imported legacy JSON across daemon restarts", async () => {
+    const { config, cleanup } = await createBootstrapConfig();
+    writeLegacyProjectWorkspaceJson(config.paseoHome, {
+      projects: [
+        {
+          projectId: "project-1",
+          rootPath: "/tmp/project-1",
+          kind: "git",
+          displayName: "Project One",
+          createdAt: "2026-03-01T00:00:00.000Z",
+          updatedAt: "2026-03-02T00:00:00.000Z",
+          archivedAt: null,
+        },
+      ],
+      workspaces: [
+        {
+          workspaceId: "workspace-1",
+          projectId: "project-1",
+          cwd: "/tmp/project-1",
+          kind: "local_checkout",
+          displayName: "main",
+          createdAt: "2026-03-01T00:00:00.000Z",
+          updatedAt: "2026-03-02T00:00:00.000Z",
+          archivedAt: null,
+        },
+      ],
+    });
+
+    try {
+      const firstDaemon = await createPaseoDaemon(config, pino({ level: "silent" }));
+      await firstDaemon.start();
+      await firstDaemon.stop();
+
+      const secondDaemon = await createPaseoDaemon(config, pino({ level: "silent" }));
+      await secondDaemon.start();
+      await secondDaemon.stop();
+
+      const database = await openPaseoDatabase(path.join(config.paseoHome, "db"));
+      try {
+        expect(await database.db.select().from(projects)).toHaveLength(1);
+        expect(await database.db.select().from(workspaces)).toHaveLength(1);
+      } finally {
+        await database.close();
+      }
+    } finally {
+      await cleanup();
+    }
+  });
+
+  test("reconciles workspace records into the DB without recreating legacy JSON registry files", async () => {
+    const { config, cleanup } = await createBootstrapConfig();
+    const agentStorageDir = path.join(config.paseoHome, "agents");
+    mkdirSync(agentStorageDir, { recursive: true });
+    const storageBucket = path.join(agentStorageDir, "tmp-db-only-project");
+    mkdirSync(storageBucket, { recursive: true });
+    writeFileSync(
+      path.join(storageBucket, "agent-1.json"),
+      JSON.stringify(
+        {
+          id: "agent-1",
+          provider: "codex",
+          cwd: "/tmp/db-only-project",
+          createdAt: "2026-03-01T00:00:00.000Z",
+          updatedAt: "2026-03-02T00:00:00.000Z",
+          lastActivityAt: "2026-03-02T00:00:00.000Z",
+          lastUserMessageAt: null,
+          title: null,
+          labels: {},
+          lastStatus: "idle",
+          lastModeId: null,
+          config: null,
+          runtimeInfo: { provider: "codex", sessionId: null },
+          persistence: null,
+          archivedAt: null,
+        },
+        null,
+        2,
+      ),
+      "utf8",
+    );
+
+    try {
+      const daemon = await createPaseoDaemon(config, pino({ level: "silent" }));
+      await daemon.start();
+      await daemon.stop();
+
+      const database = await openPaseoDatabase(path.join(config.paseoHome, "db"));
+      try {
+        expect(await database.db.select().from(agentSnapshots)).toEqual([
+          expect.objectContaining({
+            agentId: "agent-1",
+            cwd: "/tmp/db-only-project",
+            requiresAttention: false,
+            internal: false,
+          }),
+        ]);
+        expect(await database.db.select().from(projects)).toHaveLength(1);
+        expect(await database.db.select().from(workspaces)).toHaveLength(1);
+      } finally {
+        await database.close();
+      }
+
+      expect(existsSync(path.join(config.paseoHome, "projects", "projects.json"))).toBe(false);
+      expect(existsSync(path.join(config.paseoHome, "projects", "workspaces.json"))).toBe(false);
+    } finally {
+      await cleanup();
+    }
+  });
 });
+
+async function createBootstrapConfig(): Promise<{
+  config: PaseoDaemonConfig;
+  cleanup: () => Promise<void>;
+}> {
+  const paseoHomeRoot = await mkdtemp(path.join(os.tmpdir(), "paseo-bootstrap-db-"));
+  const paseoHome = path.join(paseoHomeRoot, ".paseo");
+  const staticDir = await mkdtemp(path.join(os.tmpdir(), "paseo-static-"));
+  await mkdir(paseoHome, { recursive: true });
+
+  return {
+    config: {
+      listen: "127.0.0.1:0",
+      paseoHome,
+      corsAllowedOrigins: [],
+      allowedHosts: true,
+      mcpEnabled: false,
+      staticDir,
+      mcpDebug: false,
+      agentClients: createTestAgentClients(),
+      agentStoragePath: path.join(paseoHome, "agents"),
+      relayEnabled: false,
+      appBaseUrl: "https://app.paseo.sh",
+      openai: undefined,
+      speech: undefined,
+    },
+    cleanup: async () => {
+      await rm(paseoHomeRoot, { recursive: true, force: true });
+      await rm(staticDir, { recursive: true, force: true });
+    },
+  };
+}
+
+function writeLegacyProjectWorkspaceJson(
+  paseoHome: string,
+  input: {
+    projects: unknown[];
+    workspaces: unknown[];
+  },
+): void {
+  const projectsDir = path.join(paseoHome, "projects");
+  mkdirSync(projectsDir, { recursive: true });
+  writeFileSync(path.join(projectsDir, "projects.json"), JSON.stringify(input.projects, null, 2), "utf8");
+  writeFileSync(path.join(projectsDir, "workspaces.json"), JSON.stringify(input.workspaces, null, 2), "utf8");
+}
@@ -35,43 +35,34 @@ function resolveBoundListenTarget(
  };
 }

-// Matches a Windows drive-letter path like C:\ or D:\
-const WINDOWS_DRIVE_RE = /^[A-Za-z]:\\/;
-
 export function parseListenString(listen: string): ListenTarget {
-  // 1. Windows named pipes: \\.\pipe\... or pipe://...
  if (listen.startsWith("\\\\.\\pipe\\") || listen.startsWith("pipe://")) {
    return {
      type: "pipe",
      path: listen.startsWith("pipe://") ? listen.slice("pipe://".length) : listen,
    };
  }
-  // 2. Explicit unix:// prefix
+  // Unix socket: starts with / or ~ or contains .sock
+  if (listen.startsWith("/") || listen.startsWith("~") || listen.includes(".sock")) {
+    return { type: "socket", path: listen };
+  }
+  // Explicit unix:// prefix
  if (listen.startsWith("unix://")) {
    return { type: "socket", path: listen.slice(7) };
  }
-  // 3. Reject Windows absolute drive paths — they are not Unix sockets
-  if (WINDOWS_DRIVE_RE.test(listen)) {
-    throw new Error(`Invalid listen string (Windows path is not a valid listen target): ${listen}`);
-  }
-  // 4. POSIX absolute path (/ or ~) — Unix socket
-  if (listen.startsWith("/") || listen.startsWith("~")) {
-    return { type: "socket", path: listen };
-  }
-  // 5. Pure numeric — TCP port on 127.0.0.1
-  const trimmed = listen.trim();
-  if (/^\d+$/.test(trimmed)) {
-    const port = parseInt(trimmed, 10);
-    return { type: "tcp", host: "127.0.0.1", port };
-  }
-  // 6. host:port — TCP
+  // TCP: host:port or just port
  if (listen.includes(":")) {
    const [host, portStr] = listen.split(":");
-    const parsedPort = parseInt(portStr, 10);
-    if (!Number.isFinite(parsedPort)) {
+    const port = parseInt(portStr, 10);
+    if (!Number.isFinite(port)) {
      throw new Error(`Invalid port in listen string: ${listen}`);
    }
-    return { type: "tcp", host: host || "127.0.0.1", port: parsedPort };
+    return { type: "tcp", host: host || "127.0.0.1", port };
+  }
+  // Just a port number
+  const port = parseInt(listen, 10);
+  if (Number.isFinite(port)) {
+    return { type: "tcp", host: "127.0.0.1", port };
  }
  throw new Error(`Invalid listen string: ${listen}`);
 }
@@ -93,12 +84,17 @@ import type { LocalSpeechProviderConfig } from "./speech/providers/local/config.
 import type { RequestedSpeechProviders } from "./speech/speech-types.js";
 import { initializeSpeechRuntime } from "./speech/speech-runtime.js";
 import { AgentManager } from "./agent/agent-manager.js";
-import { AgentStorage } from "./agent/agent-storage.js";
-import { attachAgentStoragePersistence } from "./persistence-hooks.js";
+import type { AgentSnapshotStore } from "./agent/agent-snapshot-store.js";
 import { createAgentMcpServer } from "./agent/mcp-server.js";
 import { createAllClients, shutdownProviders } from "./agent/provider-registry.js";
 import { bootstrapWorkspaceRegistries } from "./workspace-registry-bootstrap.js";
-import { FileBackedProjectRegistry, FileBackedWorkspaceRegistry } from "./workspace-registry.js";
+import { DbAgentSnapshotStore } from "./db/db-agent-snapshot-store.js";
+import { DbAgentTimelineStore } from "./db/db-agent-timeline-store.js";
+import { DbProjectRegistry } from "./db/db-project-registry.js";
+import { DbWorkspaceRegistry } from "./db/db-workspace-registry.js";
+import { importLegacyAgentSnapshots } from "./db/legacy-agent-snapshot-import.js";
+import { importLegacyProjectWorkspaceJson } from "./db/legacy-project-workspace-import.js";
+import { openPaseoDatabase, type PaseoDatabaseHandle } from "./db/pglite-database.js";
 import { createTerminalManager, type TerminalManager } from "../terminal/terminal-manager.js";
 import { createConnectionOfferV2, encodeOfferToFragmentUrl } from "./connection-offer.js";
 import { loadOrCreateDaemonKeyPair } from "./daemon-keypair.js";
@@ -188,7 +184,7 @@ export type PaseoDaemonConfig = {
 export interface PaseoDaemon {
  config: PaseoDaemonConfig;
  agentManager: AgentManager;
-  agentStorage: AgentStorage;
+  agentStorage: AgentSnapshotStore;
  terminalManager: TerminalManager;
  start(): Promise<void>;
  stop(): Promise<void>;
@@ -206,6 +202,7 @@ export async function createPaseoDaemon(
  const pidLockMode = config.pidLock?.mode ?? "self";
  const pidLockOwnerPid = config.pidLock?.ownerPid;
  const ownsPidLock = pidLockMode === "self";
+  let database: PaseoDatabaseHandle | null = null;

  // Acquire PID lock before expensive bootstrap work so duplicate starts fail immediately.
  if (ownsPidLock) {
@@ -365,15 +362,27 @@ export async function createPaseoDaemon(

    const httpServer = createHTTPServer(app);

-    const agentStorage = new AgentStorage(config.agentStoragePath, logger);
-    const projectRegistry = new FileBackedProjectRegistry(
-      path.join(config.paseoHome, "projects", "projects.json"),
-      logger,
-    );
-    const workspaceRegistry = new FileBackedWorkspaceRegistry(
-      path.join(config.paseoHome, "projects", "workspaces.json"),
-      logger,
-    );
+    database = await openPaseoDatabase(path.join(config.paseoHome, "db"));
+    logger.info({ elapsed: elapsed() }, "Paseo database opened");
+
+    if (process.env.NODE_ENV === "development") {
+      app.post("/dev/db-query", async (req, res) => {
+        try {
+          const { sql } = req.body;
+          if (typeof sql !== "string") {
+            res.status(400).json({ error: "Missing sql string" });
+            return;
+          }
+          const result = await database!.client.query(sql);
+          res.json({ rows: result.rows });
+        } catch (err: any) {
+          res.status(400).json({ error: err.message });
+        }
+      });
+    }
+
+    const agentStorage = new DbAgentSnapshotStore(database.db);
+    const durableTimelineStore = new DbAgentTimelineStore(database.db);
    const agentManager = new AgentManager({
      clients: {
        ...createAllClients(logger, {
@@ -382,18 +391,25 @@ export async function createPaseoDaemon(
        ...config.agentClients,
      },
      registry: agentStorage,
+      durableTimelineStore,
      logger,
    });

    const terminalManager = createTerminalManager();
-
-    const detachAgentStoragePersistence = attachAgentStoragePersistence(
+    const projectRegistry = new DbProjectRegistry(database.db);
+    const workspaceRegistry = new DbWorkspaceRegistry(database.db);
+    await importLegacyProjectWorkspaceJson({
+      db: database.db,
+      paseoHome: config.paseoHome,
      logger,
-      agentManager,
-      agentStorage,
-    );
-    await agentStorage.initialize();
-    logger.info({ elapsed: elapsed() }, "Agent storage initialized");
+    });
+    logger.info({ elapsed: elapsed() }, "Legacy project/workspace import checked");
+    await importLegacyAgentSnapshots({
+      db: database.db,
+      paseoHome: config.paseoHome,
+      logger,
+    });
+    logger.info({ elapsed: elapsed() }, "Legacy agent snapshot import checked");
    await bootstrapWorkspaceRegistries({
      paseoHome: config.paseoHome,
      agentStorage,
@@ -718,8 +734,6 @@ export async function createPaseoDaemon(
    const stop = async () => {
      await closeAllAgents(logger, agentManager);
      await agentManager.flush().catch(() => undefined);
-      detachAgentStoragePersistence();
-      await agentStorage.flush().catch(() => undefined);
      await shutdownProviders(logger, {
        runtimeSettings: config.agentProviderSettings,
      });
@@ -734,6 +748,7 @@ export async function createPaseoDaemon(
      if (voiceMcpBridgeManager) {
        await voiceMcpBridgeManager.stop().catch(() => undefined);
      }
+      await database?.close().catch(() => undefined);
      await new Promise<void>((resolve) => {
        httpServer.close(() => resolve());
      });
@@ -759,6 +774,7 @@ export async function createPaseoDaemon(
      getListenTarget: () => boundListenTarget,
    };
  } catch (err) {
+    await database?.close().catch(() => undefined);
    if (ownsPidLock) {
      await releasePidLock(config.paseoHome, {
        ownerPid: pidLockOwnerPid,
@@ -224,6 +224,8 @@ describe("daemon client E2E", () => {
      expect(archivedResult).not.toBeNull();
      expect(archivedResult?.agent.archivedAt).toBeTruthy();
      expect(archivedResult?.agent.status).not.toBe("running");
+      expect(archivedResult?.agent.requiresAttention).toBe(false);
+      expect(archivedResult?.agent.attentionReason).toBeNull();
      expect(archivedResult?.project).not.toBeNull();
      expect(archivedResult?.project?.checkout.cwd).toBe(cwd);

@@ -309,6 +311,42 @@ describe("daemon client E2E", () => {
    }
  }, 180000);

+  test("update_agent persists unloaded title and labels across auto-unarchive", async () => {
+    const cwd = tmpCwd();
+    try {
+      const created = await ctx.client.createAgent({
+        config: {
+          ...getFullAccessConfig("codex"),
+          cwd,
+        },
+      });
+
+      await ctx.client.archiveAgent(created.id);
+      await ctx.client.updateAgent(created.id, {
+        name: "Pinned Title",
+        labels: { lane: "phase-1a" },
+      });
+
+      const archived = await ctx.client.fetchAgent(created.id);
+      expect(archived).not.toBeNull();
+      expect(archived?.agent.archivedAt).toBeTruthy();
+      expect(archived?.agent.title).toBe("Pinned Title");
+      expect(archived?.agent.labels).toMatchObject({ lane: "phase-1a" });
+
+      await ctx.client.sendMessage(created.id, "Say hello and nothing else");
+      const finalState = await ctx.client.waitForFinish(created.id, 120000);
+      expect(finalState.status).toBe("idle");
+
+      const unarchived = await ctx.client.fetchAgent(created.id);
+      expect(unarchived).not.toBeNull();
+      expect(unarchived?.agent.archivedAt).toBeNull();
+      expect(unarchived?.agent.title).toBe("Pinned Title");
+      expect(unarchived?.agent.labels).toMatchObject({ lane: "phase-1a" });
+    } finally {
+      rmSync(cwd, { recursive: true, force: true });
+    }
+  }, 180000);
+
  test("returns home-scoped directory suggestions", async () => {
    const insideHomeDir = mkdtempSync(path.join(homedir(), "paseo-dir-suggestion-"));
    const outsideHomeDir = mkdtempSync(path.join(tmpdir(), "paseo-dir-suggestion-outside-"));
@@ -529,7 +567,6 @@ describe("daemon client E2E", () => {
    const timelineResult = await ctx.client.fetchAgentTimeline(agent.id, {
      direction: "tail",
      limit: 1,
-      projection: "projected",
    });
    expect(timelineResult.agentId).toBe(agent.id);

@@ -756,7 +793,6 @@ describe("daemon client E2E", () => {
    const timeline = await ctx.client.fetchAgentTimeline(agent.id, {
      direction: "tail",
      limit: 0,
-      projection: "projected",
    });
    expect(timeline.entries.length).toBeGreaterThan(0);

--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Mohamed Boudra	831dba9122	Add database query CLI tool for development	2026-03-25 20:39:08 +07:00
Mohamed Boudra	296f283d44	Eliminate full timeline memory load: route committed queries to DB	2026-03-25 20:39:08 +07:00
Mohamed Boudra	f27c803bf8	fix(server): keep Claude model queries open	2026-03-25 20:39:08 +07:00
Mohamed Boudra	ce8128910e	Fix streaming double-dispatch: suppress raw chunks during provisional buffering	2026-03-25 20:39:08 +07:00
Mohamed Boudra	c2d8cbdb2e	Fix delete race: skip background persist for closed agents	2026-03-25 20:39:08 +07:00
Mohamed Boudra	05094fe9e1	Phase 5: remove legacy storage paths and dead compatibility code	2026-03-25 20:39:07 +07:00
Mohamed Boudra	6027c38f8c	Phase 4c: skip provider-history rehydrate when DB timeline is available	2026-03-25 20:39:07 +07:00
Mohamed Boudra	eae83a53d8	Phase 4b: timeline read authority cutover to DB	2026-03-25 20:39:07 +07:00
Mohamed Boudra	17dc2801db	Phase 4a: durable timeline store adapter + dual-write	2026-03-25 20:39:07 +07:00
Mohamed Boudra	3e9fd00501	Phase 3b: agent snapshot DB cutover + interface extraction	2026-03-25 20:39:07 +07:00
Mohamed Boudra	307a6e85f9	Phase 3a: project/workspace DB cutover + legacy JSON import Bootstrap now opens PGlite and uses DB-backed project/workspace registries as the sole runtime authority. Legacy JSON files are imported transactionally on first startup; restart is idempotent. Key changes: - bootstrap.ts: DB registries replace file-backed, DB lifecycle managed on startup/shutdown/error - workspace-registry-bootstrap.ts: fixed FK write order (project before workspace), uses list() instead of existsOnDisk() - New transactional import module with rollback safety - Bootstrap smoke tests for import, idempotence, and reconciliation Audit-verified: authority cutover (13/13 checks), boundary (10/10).	2026-03-25 20:39:07 +07:00
Mohamed Boudra	7f11c0c64c	Phase 2b: DB-backed project and workspace registry adapters Add DbProjectRegistry and DbWorkspaceRegistry implementing the existing ProjectRegistry/WorkspaceRegistry interfaces against Drizzle/PGlite. Real PGlite contract tests verify full behavioral parity with the file-backed implementations including FK constraints. No runtime rewiring — bootstrap and consumers untouched.	2026-03-25 20:39:07 +07:00
Mohamed Boudra	214f85a150	Phase 2a: Drizzle + PGlite database foundation Add Drizzle schema for all four tables (projects, workspaces, agent_snapshots, agent_timeline_rows), PGlite bootstrap lifecycle, migration harness, and real contract tests proving query shapes work. No runtime authority changes — Session, AgentManager, and existing storage call sites are untouched. CLI cleanup removes stale projection fields from two fetchAgentTimeline call sites. Audit-verified: correctness (all acceptance criteria met), boundary (no runtime files touched), complexity (minor flags resolved).	2026-03-25 20:39:07 +07:00
Mohamed Boudra	acda34fc70	Phase 1d: extract in-memory timeline store	2026-03-25 20:39:07 +07:00
Mohamed Boudra	ae4f9e0410	Phase 1c: isolate provider history compatibility seam	2026-03-25 20:39:07 +07:00
Mohamed Boudra	b3cdfb203b	Phase 1b: extract workspace reconciliation service	2026-03-25 20:39:07 +07:00
Mohamed Boudra	6eb6be77df	Phase 1a: collapse snapshot mutation ownership	2026-03-25 20:39:07 +07:00
Mohamed Boudra	c202bd5ff7	Phase 0: simplify timeline contract and reconnect behavior	2026-03-25 20:39:07 +07:00
Mohamed Boudra	cebde228b1	Add storage revamp implementation plan	2026-03-25 20:39:07 +07:00