How it works
From the folder to the last screen.
Each step is a place in the app: where you are, what you do, and what you see.
The project
Connect it, then watch it.
- 01
Connect a repository
- Where
- The repository list.
- You do
- Choose the project folder.
- You see
- The project is listed as Not watching. Its name and its path stay on this machine.
- 02
Start a watch
- Where
- That repository.
- You do
- Choose how the project runs, then start the watch. In this version the choices are Already running, Docker, Start with Toolkit, and Kubernetes on Team.
- You see
- The status changes to Watching, and the services that door can see appear. A plan can name SSH, AWS, Azure, and Google Cloud before those doors are opened.
Intelligence
One menu, for every door.
A Kubernetes project does not grow a second menu.
- 03
Overview
- Where
- Intelligence, Overview.
- You do
- Scan the services under the watch.
- You see
- Each service and its mark. Green means a health check reported healthy. Running with no health check stays a plain Running.
- 04
Discover
- Where
- Discover.
- You do
- See what the watch found.
- You see
- A service is live or not running. A port, a health address, and the door appear when the source stated them. On Kubernetes, expected replicas and ready replicas appear when the source stated them.
- 05
Observe
- Where
- Observe.
- You do
- Open the service whose reading you need.
- You see
- Observed, partial, or inactive. The source and the runtime. The cause is written out only here. A missing side is marked as a gap.
- 06
Normalize
- Where
- Normalize.
- You do
- Check whether state and health became one record.
- You see
- Merged, runtime only, or missing coverage, and a note of what was merged.
- 07
Topology Tree
- Where
- Topology Tree.
- You do
- Drag a node. Scroll to zoom.
- You see
- Confirmed nodes. If two readings disagree, the node says it does not match. A dependency is drawn only when the source stated it. A target the watch did not find stays unresolved.
- 08
Knowledge Graph
- Where
- Knowledge Graph.
- You do
- Read the same links as a list.
- You see
- A depends-on link only when Compose stated it. Unresolved links stay apart from the ones the source named.
Analyze
The same record, read again.
- 09
Insights
- Where
- Analyze, Insights.
- You do
- Read the services in rank order.
- You see
- Why it matters, and the evidence lines copied from the record. Runtime pressure is kept apart from a missing observation.
- 10
Timeline
- Where
- Timeline.
- You do
- Open a moment.
- You see
- The readings of one service, grouped. What happened, the supporting readings, and how many services share that minute.
- 11
Signals
- Where
- Signals.
- You do
- Scan which readings are present.
- You see
- The readings that exist, and the ones that are missing. A missing health reading is its own row. Freshness stays on the row.
- 12
Incidents
- Where
- Incidents.
- You do
- Open a service.
- You see
- The related readings under that service. The existing rank is shown as Critical, High, Medium, or Low.
- 13
Inference
- Where
- Inference.
- You do
- Read the causes the source stated.
- You see
- The record, cited, for every service that has a stated cause. Runtime, a missing observation, and configuration stay separate.
- 14
Consistency
- Where
- Consistency.
- You do
- Compare the two sides.
- You see
- Desired next to observed, when the source has both. On Kubernetes, desired replicas and ready replicas.
- 15
Recommendations
- Where
- Recommendations.
- You do
- Look for a solution that has been linked.
- You see
- The effect of that solution. If nothing is linked, the screen is empty. It does not write an action of its own.
The manual
The detail is in Docs.
This page is the path. Docs is where each door and each field is written out.