# AWP Product Design Progress

**Date:** 2026-08-20  
**Status:** **DESIGN COMPLETE FOR I1 — IMPLEMENTATION PHASE STARTING**  
**Finalization record:** [`AWP-SPECIFICATION-FINALIZATION-2026-08-20.md`](AWP-SPECIFICATION-FINALIZATION-2026-08-20.md)  
**Parallel implementation:** [`AWP-I0-I1-PARALLEL-IMPLEMENTATION-PLAN.md`](AWP-I0-I1-PARALLEL-IMPLEMENTATION-PLAN.md)

## Durability Rule

Material decisions, product/architecture intent, mockup approvals, unresolved evidence gates and next-step state live in canonical repository documents. Chat history is not required to reconstruct product intent.

## Product Premise

AWP is the polished Agentic Software Delivery Control Plane successor to the Overdeck experiment:

```text
no accidental architecture
no workstation authority for normal agent work
no user-facing UI invented during implementation
no agent-only unreadable specs
no incremental implementation that forgets the final product
no visual drift from temporary layouts
no rebuilding generic mechanics before reuse/source/provider proof
```

AWP's dominant product mental model is project/product management, not a low-level orchestration console.

## Ratified Development Model

```text
FULL TARGET SPECIFICATION
  architecture + ADRs + domains + workflows + UI/IA + schemas
        ↓
OWNER-VISION / FOSS / REUSE / PAGE-COMPLETENESS TRACE
        ↓
OWNER-APPROVED FULL-TARGET HIGH-FI
        ↓
EXACT SOURCE / PROVIDER EVIDENCE FOR CONSUMED SUBSYSTEM
        ↓
INCREMENTAL IMPLEMENTATION
I0 -> I1 -> ... -> I9
        ↓
DOGFOOD + explicit Decision/spec amendment when evidence changes design
```

## Final Product Model

```text
ProjectVision
  enduring product intent

Goal
  current/future Project outcome

Plan
  bounded work advancing one or more Goals

Task
  executable work with hard dependencies

Queue
  dependency/policy-constrained dispatch ordering
```

`GOLIVE` is not a first-class primitive. Launch is a Goal use case with readiness criteria/evidence.

Execution/trusted-publication lifecycle:

```text
Plan -> Task -> FactoryRun -> AgentRun -> Attempt -> Workspace -> ChangeSet -> Review -> trusted Merge
```

Normal execution agents do not own reusable publication/merge credentials.

## Specification Status

```text
Architecture / provider boundaries       FINAL
Architecture Decisions / ADRs            FINAL
Core domain model                        FINAL
ProjectVision / Goal / Plan              FINAL
Planning domain                          FINAL TARGET SEMANTICS
Work / dependency Queue                  FINAL
Factory / Agent / Change / Review        FINAL
Advisor Personas / advisory agents       FINAL TARGET SEMANTICS
Advanced Search / command palette        FINAL TARGET SEMANTICS
CI / Verification                        FINAL TARGET SEMANTICS
Artifact / Release / Deployment          FINAL TARGET SEMANTICS
Cluster / Incident / Reliability         FINAL TARGET SEMANTICS
Configuration / Policy / Connections     FINAL
Cross-domain workflows                   FINAL
Whole-product UI / information arch.     FINAL TARGET BEHAVIOR
Schema / transport / adapter contracts   FINAL
I0..I9 realization map                   FINAL
I0/I1 threat model                       COMPLETE DESIGN
I1 U1–U6 visual design                   OWNER APPROVED / FINAL
Specification phase                      CLOSED
Implementation                           AUTHORIZED TO START I0
```

## I1 Owner-Approved Visual Set

```text
U1  Project Overview                         FINAL
U2  Active FactoryRun                        FINAL
U3  Waiting / Failure / Retry + WIP safety  FINAL
U4  ChangeSet / Review                       FINAL
U5  Ready to Merge                           FINAL
U6  Merged / Completed                       FINAL
```

Authority: [`../mockups/i1/README.md`](../mockups/i1/README.md).

### U1 product-manager hierarchy

```text
Current Goals / Needs Your Attention / Blockers
Active Plans / FactoryRuns / Recently Completed
Queue / Next Up: Now / Next / Later / Waiting / Blocked
Project health / freshness / timezone
```

### U2/U3 execution hierarchy

```text
Task Progress & Topology
Active AgentRuns / Recovery & Attempts
Latest Activity
WIP / Checkpoint Safety
ChangeSet / Review
Current / Next / Attention
```

### U4/U5/U6 trusted-review hierarchy

```text
exact candidate/base identity
changed files + real diff
findings + verification evidence
producer/reviewer provenance
MergeGate / one primary next action
```

## Visual Language Locked for I1

- near-black/navy shell;
- compact operational density;
- restrained purple accent;
- thin blue/navy borders;
- names before IDs;
- small semantic state pills;
- one dominant primary action per decision context;
- destructive actions separated;
- no generic KPI-card hierarchy;
- no giant hero/glassmorphism/marketing composition;
- failure/recovery explains state and WIP safety before raw logs.

Material I1 page relocation or state-semantic changes require owner-approved amendment.

## Advisor / Search Target

```text
Planning                 one Plan creation/revision
Project Manager Advisor  one Project across Goals/Plans/lifecycle
AWP Advisor              all resources authorized to Principal
Execution Agent chat     one AgentRun/Attempt
```

Search/CmdK and Project Manager placement are already designed where layout-relevant, but behavior activates in I3. AWP system Advisor activates in I4.

## Reuse / Evidence State

Current Platform source baseline recorded by preflight:

```text
platform-modules/mod
main revision b7c7f97fa0c51a1cc2f5d87ee752a3c08a08495a
Node 22.x
pnpm 9.7.0
```

Remaining exact source/live proofs are implementation evidence lanes, not design gaps:

```text
Overdeck physical current-source harvest
Platform exact AWP consumer pins/tests
Subrouter runtime adapter proof
DBOS crash/recovery
K3s Workspace/WIP recovery
gVisor / Dev Container representative compatibility
Fabro / ACP runtime mappings
ARC ephemeral runner E2E
trusted publication/merge E2E
executable security mitigations
```

## Increment Boundary

```text
I0  Foundation / self-hosting substrate
I1  Project + ProjectVision + Goal -> Plan -> Task/Queue -> FactoryRun -> AgentRun/Attempt -> ChangeSet -> Review -> Merge
I2  Real Planning + full Goal management/readiness
I3  Decisions/Approvals/Autonomy + Project Manager + Search
I4  full Factory/Agent observability + AWP Advisor
I5  CI control plane
I6  Release/Deployment
I7  Cluster product surface
I8  self-healing Incident/Resolver
I9  enterprise + reliability/SLO
```

## Next Phase

Parallel implementation is now binding:

```text
A0  bootstrap / root architecture convergence          first development agent
A   core domain / application / persistence
B   account/VCS/Fabro/ACP provider lane
C   DBOS/K8s/Workspace/ARC execution lane
D   I1 web UI against approved U1–U6
E   exact Overdeck/source evidence lane
```

A0 lands convergence point C0 before B/C/D code lanes branch. E can run immediately because it writes only evidence/progress files.

Launch authority:

- [`AWP-I0-DEVELOPMENT-AGENT-1-PROMPT.md`](AWP-I0-DEVELOPMENT-AGENT-1-PROMPT.md)
- [`AWP-I0-I1-PARALLEL-IMPLEMENTATION-PLAN.md`](AWP-I0-I1-PARALLEL-IMPLEMENTATION-PLAN.md)

## Immediate Next Work

```text
1. land this finalization batch
2. launch Development Agent 1 on I0-A0 Bootstrap
3. optionally launch Lane E source harvest immediately in parallel
4. Agent 1 lands C0 convergence commit
5. launch A/B/C/D code lanes from exact landed C0/main
6. close lane-owned source/runtime/security evidence
7. pass I0 exit
8. dogfood I1 through approved U1 -> U6 lifecycle
```

No further broad design phase is required before implementation.