docs(readme): Streamline

Author: ditsuke

README.md

@@ -1,67 +1,53 @@
 # Worktee
 
-`wtt` is a safe Git worktree manager for Linux and macOS. It indexes repositories, provides fast
+`wtt` is a Git worktree manager: index worktrees, fast interactive
 fuzzy switching and a full-screen dashboard, creates managed worktrees, and plans removals and
 pruning without weakening Git safety checks.
 
-The project is under active, pre-release development. The core CLI, incremental indexing daemon,
-interactive picker, Mission dashboard, GitHub provider integration, and safety-planned mutations
-are implemented. Release hardening is still in progress; see
-[`PLAN.md`](PLAN.md) and [`ISSUES.md`](ISSUES.md) for current status.
-
-Windows support is deferred until process-tree cleanup and shell integration can provide the same
-safety guarantees.
-
 ## Install
 
-WTT currently installs from source. It requires Git and the Rust toolchain pinned by this
-repository. Clone the repository, then run:
+WTT requires Git and a Rust toolchain. Install the published crate with:
 
 ```sh
-cargo install --path . --locked
+cargo install worktee
 ```
 
-This installs the `wtt` binary. GitHub pull-request status is optional and uses the authenticated
-[`gh`](https://cli.github.com/) CLI; all local worktree features continue to work without it.
+To install the current source checkout instead, run `cargo install --path . --locked` from the
+repository root.
 
-The first interactive non-metadata command prompts for scan roots before creating an editable,
-commented default configuration. Its removable `~/ghq` suggestion is inspired by
-[ghq](https://github.com/x-motemen/ghq), a lovely tool for organizing remote repository clones.
-Non-interactive first runs retain an empty scan-root list. The generated file includes
-schema-derived section and setting guidance and labels normal intent separately from advanced
-safety controls. An explicitly supplied, missing `--config` path remains an error.
+Both methods install the `wtt` binary. GitHub pull-request status is optional and uses the
+authenticated [`gh`](https://cli.github.com/) CLI; all local worktree features continue to work
+without it.
 
 ## Quick start
 
-Tell WTT where your repositories live. Values use TOML syntax, so replace the example with one or
-more absolute paths:
+Run WTT and follow the setup wizard. It creates an editable, commented configuration and asks which
+folders contain your Git repositories:
 
 ```sh
-wtt config set scan_roots '["/path/to/repos"]'
+wtt
 ```
 
-Start the daemon, wait for the initial scan, and inspect the index:
+WTT starts the daemon automatically. Wait for the initial scan, then inspect the index:
 
 ```sh
-wtt daemon start --detach --if-needed
 wtt scan --wait
 wtt list --all
 ```
 
-Install shell integration so `wtt switch` can change the directory of your current shell:
+## Shell integration
 
-```sh
-# Bash: add to ~/.bashrc
-eval "$(wtt shell init bash)"
+Plug into your configuration
 
-# Zsh: add to ~/.zshrc
-eval "$(wtt shell init zsh)"
+```bash
+wtt shell init <bash|fish|zsh> # required for the switcher to work
+```
 
-# Fish: add to ~/.config/fish/config.fish
-wtt shell init fish | source
+```bash
+wtt shell completions <bash|fish|zsh> # optional
 ```
 
-Restart the shell or source its startup file, then try:
+St
 
 ```sh
 wtt switch
@@ -118,95 +104,20 @@ wtt create feature-api --new-branch feature/api
 wtt tui
 ```
 
-Mission is the global repository and worktree inventory. It starts with a focused view of active or
-uncertain pull-request work and hides quiet main worktrees. Use `Show all` or clear the filter chips
-to reveal the complete index.
+Mission is the global repository and worktree inventory. It starts with a focused view of active worktrees.
+Use `Show all` or clear the filter chips to reveal the complete index.
 
-Useful default controls include:
-
-- `j` / `k`: move through rows;
-- `/`: search with fuzzy text and structured filters;
-- `Enter`: inspect the selected worktree and its actions;
-- `?` or `Ctrl-P`: open Commands;
-- `,` / `s`: change grouping or sorting;
-- `r` / `R`: refresh the current or visible provider state;
-- `!`: open diagnostics;
-- `q`: quit.
-
-Run `wtt config reference` to see every stable TUI action name and its bindings. Bindings can be
-replaced under `[tui.bindings]`; an empty list intentionally leaves an action unbound while keeping
-it available in Commands.
+Use `ctrl-P` to reveal actions and shortkeys, further configurable through the config file.
 
 ### Remove and prune safely
 
-Preview the validated plan before removing a worktree:
-
-```sh
-wtt remove feature --dry-run
-wtt remove feature --yes
-```
-
-Preview repository-wide pruning using provider or exact Git integration proofs:
-
-```sh
-wtt prune --merged-pr --dry-run
-wtt prune --merged-into --dry-run
-wtt prune --merged-into release/1.x --include-unmerged --dry-run --json
-wtt prune --all-repositories --merged-pr --merged-into --yes
-```
-
-Interactive mutations require confirmation; redirected mutations require `--yes`. `--yes` skips
-the prompt but never relaxes a safety check. Named overrides such as `--allow-dirty`,
-`--allow-locked`, and prune-only `--allow-unpushed` relax only their stated refusal. WTT never
-removes the main worktree, and removal retains the local branch.
-
-`--merged-into` without a branch uses each repository's structural main-worktree branch; an explicit
-value names an exact local branch. Selectors form a union. Ancestry-only pruning is fully local and
-does not contact a provider. `--include-unmerged` requires decisive Git and provider assessment and
-always retains the candidate branch, as does detached selection.
-
-The dashboard exposes the same planners. Remove and prune show their exact eligible targets and
-revalidate the confirmed plan at the mutation boundary.
-
-### Refresh GitHub state
+Prune worktrees matching certain criteria with `wtt prune`.
 
-WTT discovers GitHub pull requests through `gh`, using each branch's effective fetch and push
-remotes. Provider failures never hide local worktrees, and unknown, unavailable, stale, and known
-absence remain distinct states.
-
-```sh
-wtt refresh                       # current worktree
-wtt refresh feature               # exact worktree
-wtt refresh --repository
-wtt refresh --all
-
-wtt list --provider-refresh never
-wtt list --provider-refresh all
-wtt scan --refresh --wait          # local scan plus complete provider refresh
-```
-
-Provider collection runs only in the daemon. Read commands retain cached rows and report
-`MAYBE_STALE` when the daemon or validation coverage is unavailable; explicit refresh and prune
-fail rather than silently falling back to client-side provider work.
+- See `--help` for filters and options.
+- Supports `--dry-run`
 
 ## Configuration and daemon operation
 
-The first non-metadata command creates an editable, commented configuration when the default file
-does not exist. It starts with no scan roots. An explicitly supplied missing `--config` path is an
-error.
-
-```sh
-wtt config show
-wtt config get provider.timeout_seconds
-wtt config set provider.timeout_seconds 20
-wtt config path
-wtt config validate
-wtt config reference
-```
-
-Updates use stable dotted keys, validate the complete configuration, and atomically replace the
-file only after validation succeeds.
-
 Default paths follow XDG conventions on Linux and macOS:
 
 - configuration: `$XDG_CONFIG_HOME/wtt/config.toml`, normally `~/.config/wtt/config.toml`;
@@ -218,18 +129,6 @@ The daemon owns filesystem discovery and provider synchronization. Snapshot read
 `list`, switching, completion, and the dashboard remain responsive and never start a filesystem
 scan themselves.
 
-```sh
-wtt daemon start --detach --if-needed
-wtt daemon status
-wtt scan
-wtt scan --wait
-wtt daemon stop
-```
-
-Set `daemon.auto_start = true` to let snapshot readers start a missing daemon. By default, this is
-disabled. For a user service manager, run `wtt daemon start` in the foreground, restart it on
-failure, and send `SIGTERM` for shutdown. WTT does not install service definitions.
-
 `wtt doctor` performs read-only checks of configuration, scan roots, the index, daemon, Git,
 watchers, and shell integration:
 
@@ -239,41 +138,18 @@ wtt doctor --provider
 wtt doctor --json
 ```
 
-Doctor reports problems and recovery guidance but never repairs state.
-
-Fatal human diagnostics separate the failed condition from one deterministic recovery action. The
-stable `wtt::...` code identifies the concrete condition, the primary message states what failed,
-and an optional `help:` section gives the next safe command or decision. WTT omits a hint when it
-cannot prove one is appropriate, and never writes human hints to JSON or machine-protocol stdout.
-For example, an exact switch miss may suggest a normalized logical name, a matching global target,
-an already attached branch's worktree, or a live-preflighted `wtt switch -c` command—in that order.
-Known collisions never receive a creation command.
-
-If `doctor` reports an index created by a newer WTT version, upgrade WTT; an older binary must not
-rebuild that index. For a corrupt, unversioned, or otherwise incompatible index, first use `doctor`
-to identify the database and state paths. Stop the owning daemon, copy the complete state directory
-to a backup, and move the database plus any same-named `-wal` and `-shm` files into a separate
-retained backup location. Then start the daemon and run `wtt scan --wait` to rebuild the index from
-Git and filesystem authority. Do not delete the old files. Apply the same steps to a custom
-`--database` path at the location reported by `doctor`.
-
 ## Shell completions
 
-Generate completions from the current command graph:
-
-```sh
-wtt shell completions bash >~/.local/share/bash-completion/completions/wtt
-wtt shell completions zsh >~/.local/share/zsh/site-functions/_wtt
-wtt shell completions fish >~/.config/fish/completions/wtt.fish
-```
+`wtt shell completions SHELL` generates completions from the current command graph. Use the shell
+name and destination listed in Quick start.
 
 Create the destination directory first if necessary. WTT prints scripts but never edits shell
 configuration. Dynamic completions use cached index data only; they do not scan, contact providers,
 start the daemon, or create persistent state.
 
 ## Repository hooks
 
-Place executable setup files in `.wtt/hooks/post-create`, then install and trust their exact
+Place executable setup files in `.wtt/hooks/post-create`, then install and trust their
 contents from any worktree in the repository:
 
 ```sh
@@ -287,40 +163,3 @@ reinstalling a hook changes its digest and requires trust again; `wtt hooks revo
 
 If Git creation succeeds but hook approval or execution fails, WTT preserves the new worktree and
 reports its recovery path.
-
-## Safety model
-
-WTT treats filesystems, Git, subprocesses, provider tools, caches, and cancellation as fallible:
-
-- filesystem discovery preserves the last authoritative snapshot when a scan is partial;
-- mutations use typed safety plans and revalidate immediately before changing Git state;
-- cancellation and timeouts terminate bounded subprocess trees without publishing partial state;
-- cached state is never presented as authoritative when validation or watcher coverage is missing;
-- optional provider integration degrades without disabling local worktree operations;
-- machine output uses versioned, byte-safe JSON schemas and keeps diagnostics off stdout.
-
-For the complete behavioral contract, see [`SPEC.md`](SPEC.md).
-
-## Development
-
-The repository pins its Rust toolchain. Keep build and test artifacts in the default `./target`
-directory.
-
-```sh
-cargo build
-cargo fmt --all -- --check
-cargo clippy --all-targets --all-features -- -D warnings
-cargo test --all-targets
-git diff --check
-```
-
-Useful development overrides are available without changing the normal user configuration:
-
-```sh
-cargo run -- --config /tmp/wtt.toml --database /tmp/wtt.sqlite3 daemon start
-```
-
-Architecture and delivery sequencing are documented in
-[`PLAN.md`](PLAN.md). Focused design documents live under
-[`docs/`](docs/), and verified residual defects and unresolved product decisions live in
-[`ISSUES.md`](ISSUES.md).