TUI Dashboard

TUI Dashboard

Overview

az prototype launch opens a full-screen terminal UI (TUI) dashboard built with Textual. The dashboard provides a unified environment for running all prototype stages -- design, build, and deploy -- with live task progress tracking, a scrollable console, and an interactive prompt. Sessions run on background worker threads while the UI remains responsive.

Command

az prototype launch [--stage design|build|deploy] [--json]

Parameter	Type	Default	Description
--stage	Enum: design, build, deploy	Auto-detected	Start the TUI at a specific stage instead of auto-detecting from project state.
--json, -j	Flag	false	Output machine-readable JSON instead of formatted display.

When --stage is omitted, the orchestrator inspects .prototype/state/ files to determine the furthest completed stage and resumes from there.

Layout

The TUI is organized into four regions:

+-----------------------------+------------------+
|     Console (RichLog)       |  Tasks (Tree)    |
|  scrollable, new at bottom  |  collapsible     |
+-----------------------------+------------------+
|  Prompt (TextArea)                             |
+---------------------------+--------------------+
|  Assist (left 50%)        | Status (right 50%) |
+---------------------------+--------------------+

• Console (top-left) -- A scrollable RichLog that displays all session output: welcome banners, agent responses, stage progress, and error messages. New content appears at the bottom.
• Task Tree (top-right) -- A collapsible tree widget showing the four root stages (Initialize, Design, Build, Deploy) with dynamic sub-tasks that appear as each stage progresses.
• Prompt (middle) -- A growable TextArea input where users type commands and responses. It auto-grows vertically up to 10 lines for multi-line input. The prompt is disabled while the system is processing and re-enabled when user input is needed.
• Info Bar (bottom) -- A single-line status area split into two halves: the left side shows keyboard hints ("Enter = submit | Ctrl+J = newline | Ctrl+C = quit"), and the right side shows token usage and status information.

Stage Navigation

On launch, the orchestrator detects the current project state by examining state files:

State File	Detected Stage
deploy.yaml exists	deploy
build.yaml exists	build
discovery.yaml or design.json exists	design
None of the above	init

All stages up to and including the detected stage are marked as completed in the task tree. If the target stage (via --stage) is the next logical step, it is marked as in-progress rather than completed. If the target stage would skip one or more prerequisite stages (e.g., --stage deploy when only init has completed), the orchestrator prints a warning and falls back to the next valid stage. The orchestrator then displays project metadata (name, location, IaC tool, AI provider, model) and enters the command loop.

From the command loop, users can switch between stages by typing the stage name:

Command	Aliases	Action
design	redesign	Run or re-run the design stage (discovery + architecture)
build	continue	Run or re-run the build stage
deploy	redeploy	Run or re-run the deploy stage
help	--	Show the list of available commands
quit	q, exit, end	Exit the TUI

Stages are re-entrant. Running a stage that has already completed will re-run it, allowing iterative refinement.

Slash Commands

Each stage session provides its own set of slash commands accessible from the prompt. These commands are available within the interactive session for that stage, not from the top-level command loop.

Design Stage (Discovery Session)

Command	Description
/open	List open items needing resolution
/confirmed	List confirmed requirements
/status	Show overall discovery status with open item details
/summary	Generate a narrative summary of progress so far (uses AI)
/why <topic>	Find the exchange where a topic was discussed
/restart	Clear state and restart discovery from scratch
/help	Show available commands
done	Complete discovery and proceed to architecture generation
quit	Cancel and exit

Natural language alternatives are also supported (e.g., "what are the open items" instead of /open, "give me a summary" instead of /summary).

Build Stage

Command	Description
/status	Show stage completion summary
/stages	Show full deployment plan
/files	List all generated files
/policy	Show policy check summary
/describe N	Show details for stage N
/help	Show available commands
done	Accept build and exit
quit	Cancel and exit

Deploy Stage

Command	Description
/status	Show deployment progress per stage
/stages	List all stages with status (alias for /status)
/deploy [N]	Deploy stage N, a substage (e.g., 5a), or all pending stages
/rollback [N]	Roll back stage N or all deployed stages (reverse order)
/redeploy N	Rollback and redeploy stage N
/plan N	Show what-if (Bicep) or terraform plan for stage N
/split N	Split a stage into named substages
/destroy N	Destroy resources for a stage (with confirmation)
/manual N	Add or view manual step instructions for stage N
/describe N	Show details for stage N
/outputs	Show captured deployment outputs from Terraform/Bicep
/preflight	Re-run preflight checks
/login	Run az login interactively
/help	Show available commands
done	Accept deployment and exit
quit	Exit deploy session

Stage references accept substage labels (e.g., /deploy 5a). Multi-stage operations are supported via natural language (e.g., "deploy stages 3 and 4").

Backlog Session (via az prototype generate backlog)

Command	Description
/add	Add a new backlog item (AI-assisted)
/push	Push items to GitHub or Azure DevOps
/status	Show push status per item
/help	Show available commands
/quit	Exit session
done	Finish and exit

Task Tree

The task tree provides a visual representation of pipeline progress. It has four permanent root nodes:

• Initialize -- Always marked as completed on launch.
• Design -- Expands to show sub-tasks like "Confirmed requirements (N)", "Open items (N)", and "Architecture document".
• Build -- Expands to show deployment plan stages (e.g., "Stage 1: Networking", "Stage 2: Data") with per-stage status.
• Deploy -- Expands to show the same stages with deployment-specific statuses.

Each node displays a status symbol:

Symbol	Status	Meaning
(open circle)	Pending	Not yet started
(filled circle)	In Progress	Currently running
(check mark)	Completed	Finished successfully
(X mark)	Failed	Encountered an error

Nodes automatically expand when their status transitions to In Progress and collapse when they reach Completed or Failed. Sub-tasks are dynamically added and removed as stages execute.

Keyboard Shortcuts

Key	Action
Enter	Submit the current prompt input
Shift+Enter	Insert a newline (requires Kitty keyboard protocol support)
Ctrl+J	Insert a newline (universal fallback for all terminals)
Ctrl+C	Quit the application

The prompt input uses a > prefix to indicate input mode. When the system is processing, the prompt is disabled (read-only) and re-enabled when user input is needed. In pagination mode (e.g., "press Enter to continue"), the prefix is hidden and a placeholder message is shown instead.

Tips

• Let auto-detection work. Launch without --stage and the orchestrator will resume where you left off based on your project's state files.
• Use natural language. All stage sessions support natural language in addition to slash commands. Type "what's the build status" instead of /status, or "deploy stage 3" instead of /deploy 3.
• Check status often. Use /status within any stage session to see a snapshot of progress, confirmed requirements, generated files, or deployment state.
• Iterate freely. Stages are re-entrant. Type design from the command loop to re-run discovery and refine your architecture, then build to regenerate code.
• Use /plan before deploying. In the deploy session, run /plan N to preview what Terraform or Bicep will change before committing with /deploy N.
• Substage control. If a deploy stage is too coarse, use /split N to break it into named substages for finer-grained deployment control.
• Multi-line input. For longer responses during discovery, use Ctrl+J to insert newlines before submitting with Enter.
• Review preflight results. In the deploy session, run /preflight to verify Azure login, subscription, tenant, and IaC tooling before deploying.